From be6ea7dca340e9bc026d13a648364c5efc0e5386 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 20:27:07 +0000
Subject: [PATCH 01/19] Fix message extraction and keyboard input handling

Refactor message extraction to handle keyboard input flag correctly.
---
 src/tjc.py | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/tjc.py b/src/tjc.py
index 0a5971e..bd55373 100644
--- a/src/tjc.py
+++ b/src/tjc.py
@@ -99,11 +99,13 @@ def _extract_fixed_length_packet(self, expected_length):
                     self.buffer = self.buffer[expected_length + 1:]
                     return full_message[:-3], was_keyboard_input
 
-            message = self._extract_varied_length_packet()
-            if message is None:
-                return None, was_keyboard_input
+            # ⬇⬇ FIX STARTS HERE
+            msg, kb_from_var = self._extract_varied_length_packet()
+            if msg is None:
+                # propagate any keyboard flag we might have gotten
+                return None, was_keyboard_input or kb_from_var
 
-            self.dropped_buffer += message + self.EOL
+            self.dropped_buffer += msg + self.EOL
             return self._extract_packet()
 
         self.buffer = self.buffer[expected_length:]

From e49356595bed196a27aa9b1b9db22b05ffe5e9be Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 20:34:07 +0000
Subject: [PATCH 02/19] Improve error handling in display.py

Added exception handling for unexpected errors in signal handler, request sending, and thumbnail fetching.
---
 display.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/display.py b/display.py
index 4b3f095..a21b5ee 100644
--- a/display.py
+++ b/display.py
@@ -25,6 +25,7 @@ def signal_handler(signum, frame):
     try:
         loop.call_soon_threadsafe(loop.stop)
     except Exception:
+        logger.exception("Unexpected error signal_handler")
         pass
 
 # Register signal handlers
@@ -1260,6 +1261,7 @@ async def _send_moonraker_request(self, method, params=None):
                 self.pending_reqs.pop(message["id"], None)
             raise
         except Exception:
+            logger.exception("Unexpected error _send_moonraker_request")
             await self.close()
             raise
 
@@ -1732,6 +1734,7 @@ async def fetch_and_parse_thumbnail(self, path):
                 try:
                     thumbnail.close()
                 except Exception:
+                    logger.exception("Unexpected error fetch_and_parse_thumbnail")
                     pass
 
     async def handle_status_update(self, new_data, data_mapping=None):

From b1e72279aadde0e38d66c0a409ed54204f842f81 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 20:47:33 +0000
Subject: [PATCH 03/19] Refactor signal handling and logging setup

Refactor signal handling for graceful shutdown and improve logging.
---
 display.py | 44 +++++++++++++++++++++++++-------------------
 1 file changed, 25 insertions(+), 19 deletions(-)

diff --git a/display.py b/display.py
index a21b5ee..1a5a378 100644
--- a/display.py
+++ b/display.py
@@ -2,7 +2,6 @@
 import sys
 import logging
 import pathlib
-import requests
 import re
 import os
 import os.path
@@ -14,24 +13,6 @@
 import signal
 import systemd.daemon
 
-# Global flag for graceful shutdown
-_shutdown_requested = False
-
-def signal_handler(signum, frame):
-    global _shutdown_requested
-    _shutdown_requested = True
-    log = logging.getLogger(__name__)
-    log.info(f"Received signal {signum}, initiating graceful shutdown...")
-    try:
-        loop.call_soon_threadsafe(loop.stop)
-    except Exception:
-        logger.exception("Unexpected error signal_handler")
-        pass
-
-# Register signal handlers
-signal.signal(signal.SIGTERM, signal_handler)
-signal.signal(signal.SIGINT, signal_handler)
-
 from PIL import Image
 
 from src.config import TEMP_DEFAULTS, ConfigHandler
@@ -83,6 +64,31 @@ def signal_handler(signum, frame):
 )
 from src.colors import BACKGROUND_SUCCESS, BACKGROUND_WARNING
 
+# Global flag for graceful shutdown
+_shutdown_requested = False
+
+# Create module-level logger and event loop early
+logger = logging.getLogger(__name__)
+loop = asyncio.get_event_loop()
+
+def signal_handler(signum, frame):
+    global _shutdown_requested
+    _shutdown_requested = True
+    logger.info("Received signal %s, initiating graceful shutdown...", signum)
+    try:
+        loop.call_soon_threadsafe(loop.stop)
+    except Exception:
+        # Log the error instead of swallowing it silently
+        logger.exception("Unexpected error in signal_handler")
+
+# Register signal handlers
+signal.signal(signal.SIGTERM, signal_handler)
+signal.signal(signal.SIGINT, signal_handler)
+
+# Register signal handlers
+signal.signal(signal.SIGTERM, signal_handler)
+signal.signal(signal.SIGINT, signal_handler)
+
 log_file = os.path.expanduser("~/printer_data/logs/display_connector.log")
 logger = logging.getLogger(__name__)
 ch_log = logging.StreamHandler(sys.stdout)

From 4ae362e9c58500557608d25530d5691ea1864817 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 20:58:46 +0000
Subject: [PATCH 04/19] Fix import statement and update zip function usage

---
 src/lib_col_pic.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/lib_col_pic.py b/src/lib_col_pic.py
index 8de528f..92379b9 100644
--- a/src/lib_col_pic.py
+++ b/src/lib_col_pic.py
@@ -3,7 +3,7 @@
 # The ElegooNeptuneThumbnails plugin is released under the terms of the AGPLv3 or higher.
 from threading import Lock
 import numpy as np
-from PIL import Image, ImageColor
+from PIL import ImageColor
 
 thumbnail_lock = Lock()
 
@@ -81,7 +81,7 @@ def ColPicEncode(fromcolor16, picw, pich, outputdata: bytearray, outputmaxtsize,
     unique_colors, counts = np.unique(fromcolor16, return_counts=True)
     Listu16 = np.array([U16HEAD() for _ in range(len(unique_colors))])
 
-    for i, (color, qty) in enumerate(zip(unique_colors, counts)):
+    for i, (color, qty) in enumerate(zip(unique_colors, counts, strict=True)):
         Listu16[i].colo16 = color
         Listu16[i].qty = qty
         Listu16[i].A0 = (color >> 11) & 31

From acaa7ed993ff52e68d0ef7abe461f81f9aca12f4 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:01:29 +0000
Subject: [PATCH 05/19] Refactor current_page assignment to use direct
 attribute

---
 src/tjc.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/tjc.py b/src/tjc.py
index bd55373..9631485 100644
--- a/src/tjc.py
+++ b/src/tjc.py
@@ -205,7 +205,7 @@ async def connect(self) -> None:
             try:
                 await self._command("page main", attempts=1)
                 # if you track this, keep it in sync
-                setattr(self, "current_page", "main")
+                self.current_page = "main"
                 await asyncio.sleep(0.25)  # small settle so HMI swaps pages
             except CommandTimeout:
                 pass

From cdda38df2bb3b1110a797772be3f66f4780d0c16 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:07:21 +0000
Subject: [PATCH 06/19] Refactor dynamic imports to avoid circular imports

---
 src/elegoo_neptune3.py | 12 ++++++++----
 1 file changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/elegoo_neptune3.py b/src/elegoo_neptune3.py
index 7ef4676..c3bee1b 100644
--- a/src/elegoo_neptune3.py
+++ b/src/elegoo_neptune3.py
@@ -8,12 +8,14 @@
 
 MODELS_N3 = [MODEL_N3_REGULAR, MODEL_N3_PRO, MODEL_N3_PLUS, MODEL_N3_MAX]
 
+
 class ElegooNeptune3DisplayMapper:
     def __init__(self):
         # Dynamically import ElegooDisplayMapper to avoid circular import
-        ElegooDisplayMapper = importlib.import_module('src.elegoo_display').ElegooDisplayMapper
+        importlib.import_module("src.elegoo_display").ElegooDisplayMapper
         super().__init__()
 
+
 class ElegooNeptune3DisplayCommunicator:
     def __init__(
         self,
@@ -25,16 +27,18 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import ElegooDisplayCommunicator to avoid circular import
-        ElegooDisplayCommunicator = importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
+        importlib.import_module("src.elegoo_display").ElegooDisplayCommunicator
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooNeptune3DisplayMapper()
 
+
 class OpenNeptune3DisplayMapper:
     def __init__(self):
         # Dynamically import OpenNeptuneDisplayMapper to avoid circular import
-        OpenNeptuneDisplayMapper = importlib.import_module('src.openneptune_display').OpenNeptuneDisplayMapper
+        importlib.import_module("src.openneptune_display").OpenNeptuneDisplayMapper
         super().__init__()
 
+
 class OpenNeptune3DisplayCommunicator:
     def __init__(
         self,
@@ -46,6 +50,6 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import OpenNeptuneDisplayCommunicator to avoid circular import
-        OpenNeptuneDisplayCommunicator = importlib.import_module('src.openneptune_display').OpenNeptuneDisplayCommunicator
+        importlib.import_module("src.openneptune_display").OpenNeptuneDisplayCommunicator
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooNeptune3DisplayMapper()

From 67b3fb6a6e440d6228539304e2ec3b3e8ea1c6f3 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:08:18 +0000
Subject: [PATCH 07/19] Refactor import statements for Elegoo classes

---
 src/elegoo_custom.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/elegoo_custom.py b/src/elegoo_custom.py
index ab652a8..b7b9e21 100644
--- a/src/elegoo_custom.py
+++ b/src/elegoo_custom.py
@@ -14,8 +14,8 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import ElegooDisplayCommunicator and ElegooDisplayMapper to avoid circular import
-        ElegooDisplayCommunicator = importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
-        ElegooDisplayMapper = importlib.import_module('src.elegoo_display').ElegooDisplayMapper
+        importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
+        importlib.import_module('src.elegoo_display').ElegooDisplayMapper
         
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooDisplayMapper()

From 63e2e15d0475e62ea75148c00b0fd252b1704636 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:09:01 +0000
Subject: [PATCH 08/19] Refactor import of ElegooDisplayMapper in
 elegoo_custom.py

Change import method for ElegooDisplayMapper to avoid circular import issues.
---
 src/elegoo_custom.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/elegoo_custom.py b/src/elegoo_custom.py
index b7b9e21..e0495d9 100644
--- a/src/elegoo_custom.py
+++ b/src/elegoo_custom.py
@@ -15,7 +15,7 @@ def __init__(
     ) -> None:
         # Dynamically import ElegooDisplayCommunicator and ElegooDisplayMapper to avoid circular import
         importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
-        importlib.import_module('src.elegoo_display').ElegooDisplayMapper
+        ElegooDisplayMapper = importlib.import_module('src.elegoo_display').ElegooDisplayMapper
         
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooDisplayMapper()

From ae41684d1c0244fcafb9e7150cd90833a1649ebe Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:11:23 +0000
Subject: [PATCH 09/19] Comment out import of ElegooDisplayCommunicator

Commented out the import of ElegooDisplayCommunicator to avoid circular import issues.
---
 src/elegoo_custom.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/elegoo_custom.py b/src/elegoo_custom.py
index e0495d9..ae8aeac 100644
--- a/src/elegoo_custom.py
+++ b/src/elegoo_custom.py
@@ -14,7 +14,7 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import ElegooDisplayCommunicator and ElegooDisplayMapper to avoid circular import
-        importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
+        #ElegooDisplayCommunicator = importlib.import_module('src.elegoo_display').ElegooDisplayCommunicator
         ElegooDisplayMapper = importlib.import_module('src.elegoo_display').ElegooDisplayMapper
         
         super().__init__(logger, model, port, event_handler, baudrate, timeout)

From c30a1012ebcf2abbac3864652a544e4099ee507f Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:13:03 +0000
Subject: [PATCH 10/19] Disable dynamic imports in ElegooNeptune3 classes

Comment out dynamic imports to avoid circular import issues.
---
 src/elegoo_neptune3.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/elegoo_neptune3.py b/src/elegoo_neptune3.py
index c3bee1b..e9d13cd 100644
--- a/src/elegoo_neptune3.py
+++ b/src/elegoo_neptune3.py
@@ -12,7 +12,7 @@
 class ElegooNeptune3DisplayMapper:
     def __init__(self):
         # Dynamically import ElegooDisplayMapper to avoid circular import
-        importlib.import_module("src.elegoo_display").ElegooDisplayMapper
+        #ElegooDisplayMapper = importlib.import_module("src.elegoo_display").ElegooDisplayMapper
         super().__init__()
 
 
@@ -27,7 +27,7 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import ElegooDisplayCommunicator to avoid circular import
-        importlib.import_module("src.elegoo_display").ElegooDisplayCommunicator
+        #ElegooDisplayCommunicator = importlib.import_module("src.elegoo_display").ElegooDisplayCommunicator
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooNeptune3DisplayMapper()
 
@@ -35,7 +35,7 @@ def __init__(
 class OpenNeptune3DisplayMapper:
     def __init__(self):
         # Dynamically import OpenNeptuneDisplayMapper to avoid circular import
-        importlib.import_module("src.openneptune_display").OpenNeptuneDisplayMapper
+        #OpenNeptuneDisplayMapper = importlib.import_module("src.openneptune_display").OpenNeptuneDisplayMapper
         super().__init__()
 
 
@@ -50,6 +50,6 @@ def __init__(
         timeout: int = 5,
     ) -> None:
         # Dynamically import OpenNeptuneDisplayCommunicator to avoid circular import
-        importlib.import_module("src.openneptune_display").OpenNeptuneDisplayCommunicator
+        #OpenNeptuneDisplayCommunicator = importlib.import_module("src.openneptune_display").OpenNeptuneDisplayCommunicator
         super().__init__(logger, model, port, event_handler, baudrate, timeout)
         self.mapper = ElegooNeptune3DisplayMapper()

From a23535b175ea1c3372b316b2f172a8ae297bf474 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:17:43 +0000
Subject: [PATCH 11/19] Improve error handling in connection methods

Log exceptions during connection handling for better debugging.
---
 src/tjc.py | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/src/tjc.py b/src/tjc.py
index 9631485..10a9131 100644
--- a/src/tjc.py
+++ b/src/tjc.py
@@ -99,7 +99,6 @@ def _extract_fixed_length_packet(self, expected_length):
                     self.buffer = self.buffer[expected_length + 1:]
                     return full_message[:-3], was_keyboard_input
 
-            # ⬇⬇ FIX STARTS HERE
             msg, kb_from_var = self._extract_varied_length_packet()
             if msg is None:
                 # propagate any keyboard flag we might have gotten
@@ -170,27 +169,31 @@ async def reconnect(self):
         try:
             try:
                 await self._connection.close()
-            except Exception:
-                pass
+            except Exception as exc:
+                # Non-fatal: log and continue trying to reconnect
+                self.logger.debug("Error while closing connection during reconnect: %r", exc)
             await self.connect()
         finally:
             # connect() will clear this when it succeeds; make sure we don't get stuck
             self.is_reconnecting = False
 
-
     async def connect(self) -> None:
         """Connect to the device with a quick, safe re-init."""
         try:
             await self._try_connect_on_different_baudrates()
             for method in ("reset_input_buffer", "reset_output_buffer", "flush"):
                 try:
-                    fn = getattr(self._connection, method)
+                    fn = getattr(self._connection, method, None)
                     if callable(fn):
                         r = fn()
                         if asyncio.iscoroutine(r):
                             await r
-                except Exception:
-                    pass
+                except Exception as exc:
+                    self.logger.debug(
+                        "Error while calling %s() on connection during setup: %r",
+                        method,
+                        exc,
+                    )
             # Make panel return detailed acks if it's awake
             try:
                 await self._command("bkcmd=3", attempts=1)

From 4c0ee18b63dc35925c4caa633144ad3a642fb24b Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:19:33 +0000
Subject: [PATCH 12/19] Remove unused import statement

---
 src/elegoo_neptune3.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/elegoo_neptune3.py b/src/elegoo_neptune3.py
index e9d13cd..a76fbc9 100644
--- a/src/elegoo_neptune3.py
+++ b/src/elegoo_neptune3.py
@@ -1,4 +1,3 @@
-import importlib
 from logging import Logger
 
 MODEL_N3_REGULAR = "N3"

From e82cd823d0a112f1c3493d8633afcbf866c1af27 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:33:29 +0000
Subject: [PATCH 13/19] Refactor DisplayCommunicator tests with fixtures

Refactor tests for DisplayCommunicator to use fixtures and improve structure.
---
 tests/communicator_test.py | 40 ++++++++++++++++++++------------------
 1 file changed, 21 insertions(+), 19 deletions(-)

diff --git a/tests/communicator_test.py b/tests/communicator_test.py
index 92f7a5e..5767852 100644
--- a/tests/communicator_test.py
+++ b/tests/communicator_test.py
@@ -1,30 +1,32 @@
 import logging
 from unittest.mock import AsyncMock
 import pytest
+
 from src.communicator import DisplayCommunicator
 
 
-@pytest.mark.asyncio
-async def test_valid_version():
-    communicator = DisplayCommunicator(logging, None, None, None)
-    communicator.get_firmware_version = AsyncMock(return_value="1.0")
-    communicator.supported_firmware_versions = ["1.0"]
-    is_valid = await communicator.check_valid_version()
-    communicator.get_firmware_version.assert_awaited_once()
-    assert is_valid
+@pytest.fixture
+def communicator():
+    # event_handler can be None for these unit tests, since we patch out I/O
+    return DisplayCommunicator(logging, "N3", "/dev/ttyS0", None)
+
+
+def test_get_device_name(communicator):
+    # Simple sanity check: constructor stores the model name
+    assert communicator.get_device_name() == "N3"
+
+
+def test_get_display_type_name(communicator):
+    # Should just be the class name
+    assert communicator.get_display_type_name() == "DisplayCommunicator"
 
-@pytest.mark.asyncio
-async def test_invalid_version():
-    communicator = DisplayCommunicator(logging, None, None, None)
-    communicator.get_firmware_version = AsyncMock(return_value="1.0")
-    communicator.supported_firmware_versions = ["2.0"]
-    is_valid = await communicator.check_valid_version()
-    communicator.get_firmware_version.assert_awaited_once()
-    assert not is_valid
 
 @pytest.mark.asyncio
-async def test_navigate():
-    communicator = DisplayCommunicator(logging, None, None, None)
+async def test_navigate(communicator):
+    # We don't want real I/O here, so patch write
     communicator.write = AsyncMock()
+
     await communicator.navigate_to("1")
-    communicator.write.assert_awaited_once_with("page 1")
\ No newline at end of file
+
+    # navigate_to blocks other writes with a blocked_key="__nav__"
+    communicator.write.assert_awaited_once_with("page 1", blocked_key="__nav__")

From fa00084ddd779fcb729642db9394fc96d52e4bac Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:41:42 +0000
Subject: [PATCH 14/19] Refactor _extract_fixed_length_packet method

Refactor _extract_fixed_length_packet method for clarity and efficiency.
---
 src/tjc.py | 74 +++++++++++++++++++++++++++---------------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/tjc.py b/src/tjc.py
index 10a9131..92a20fa 100644
--- a/src/tjc.py
+++ b/src/tjc.py
@@ -75,44 +75,44 @@ def _extract_packet(self):
             return self._extract_fixed_length_packet(expected_length)
         return self._extract_varied_length_packet()
 
-    def _extract_fixed_length_packet(self, expected_length):
-        """Extract a fixed-length packet from the buffer."""
-        if len(self.buffer) < expected_length:
-            if len(self.buffer) == 5 and self.buffer[0] in {0x71, 0x72}:
-                expected_length = 5
+        def _extract_fixed_length_packet(self, expected_length):
+            """Extract a fixed-length packet from the buffer."""
+            if len(self.buffer) < expected_length:
+                if len(self.buffer) == 5 and self.buffer[0] in {0x71, 0x72}:
+                    expected_length = 5
+                else:
+                    return None, False
+    
+            full_message = self.buffer[:expected_length]
+    
+            if full_message[0] == 0x71 and not full_message.endswith(self.EOL):
+                full_message += self.EOL
+                full_message = b"\x72" + full_message[1:]
+                was_keyboard_input = True
             else:
-                return None, False
-
-        full_message = self.buffer[:expected_length]
-
-        if full_message[0] == 0x71 and not full_message.endswith(self.EOL):
-            full_message += self.EOL
-            full_message = b"\x72" + full_message[1:]
-            was_keyboard_input = True
-        else:
-            was_keyboard_input = False
-
-        if not full_message.endswith(self.EOL):
-            if full_message[0] == 0x65:
-                full_message = self.buffer[:expected_length + 1]
-                if full_message.endswith(self.EOL):
-                    self.buffer = self.buffer[expected_length + 1:]
-                    return full_message[:-3], was_keyboard_input
-
-            msg, kb_from_var = self._extract_varied_length_packet()
-            if msg is None:
-                # propagate any keyboard flag we might have gotten
-                return None, was_keyboard_input or kb_from_var
-
-            self.dropped_buffer += msg + self.EOL
-            return self._extract_packet()
-
-        self.buffer = self.buffer[expected_length:]
-        if self.buffer.startswith(self.EOL):
-            self.buffer = self.buffer[3:]
-            was_keyboard_input = False
-
-        return full_message[:-3], was_keyboard_input
+                was_keyboard_input = False
+    
+            if not full_message.endswith(self.EOL):
+                if full_message[0] == 0x65:
+                    full_message = self.buffer[:expected_length + 1]
+                    if full_message.endswith(self.EOL):
+                        self.buffer = self.buffer[expected_length + 1:]
+                        return full_message[:-3], was_keyboard_input
+    
+                msg, kb_from_var = self._extract_varied_length_packet()
+                if msg is None:
+                    # propagate any keyboard flag we might have gotten
+                    return None, was_keyboard_input or kb_from_var
+    
+                self.dropped_buffer += msg + self.EOL
+                return self._extract_packet()
+    
+            self.buffer = self.buffer[expected_length:]
+            if self.buffer.startswith(self.EOL):
+                self.buffer = self.buffer[3:]
+                was_keyboard_input = False
+    
+            return full_message[:-3], was_keyboard_input
 
     def _extract_varied_length_packet(self):
         """Extract a varied-length packet from the buffer."""

From 2fb673e7c32f9efe5b8023f33ed165da16027b2a Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:44:40 +0000
Subject: [PATCH 15/19] Refactor _extract_fixed_length_packet method

---
 src/tjc.py | 74 +++++++++++++++++++++++++++---------------------------
 1 file changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/tjc.py b/src/tjc.py
index 92a20fa..10a9131 100644
--- a/src/tjc.py
+++ b/src/tjc.py
@@ -75,44 +75,44 @@ def _extract_packet(self):
             return self._extract_fixed_length_packet(expected_length)
         return self._extract_varied_length_packet()
 
-        def _extract_fixed_length_packet(self, expected_length):
-            """Extract a fixed-length packet from the buffer."""
-            if len(self.buffer) < expected_length:
-                if len(self.buffer) == 5 and self.buffer[0] in {0x71, 0x72}:
-                    expected_length = 5
-                else:
-                    return None, False
-    
-            full_message = self.buffer[:expected_length]
-    
-            if full_message[0] == 0x71 and not full_message.endswith(self.EOL):
-                full_message += self.EOL
-                full_message = b"\x72" + full_message[1:]
-                was_keyboard_input = True
+    def _extract_fixed_length_packet(self, expected_length):
+        """Extract a fixed-length packet from the buffer."""
+        if len(self.buffer) < expected_length:
+            if len(self.buffer) == 5 and self.buffer[0] in {0x71, 0x72}:
+                expected_length = 5
             else:
-                was_keyboard_input = False
-    
-            if not full_message.endswith(self.EOL):
-                if full_message[0] == 0x65:
-                    full_message = self.buffer[:expected_length + 1]
-                    if full_message.endswith(self.EOL):
-                        self.buffer = self.buffer[expected_length + 1:]
-                        return full_message[:-3], was_keyboard_input
-    
-                msg, kb_from_var = self._extract_varied_length_packet()
-                if msg is None:
-                    # propagate any keyboard flag we might have gotten
-                    return None, was_keyboard_input or kb_from_var
-    
-                self.dropped_buffer += msg + self.EOL
-                return self._extract_packet()
-    
-            self.buffer = self.buffer[expected_length:]
-            if self.buffer.startswith(self.EOL):
-                self.buffer = self.buffer[3:]
-                was_keyboard_input = False
-    
-            return full_message[:-3], was_keyboard_input
+                return None, False
+
+        full_message = self.buffer[:expected_length]
+
+        if full_message[0] == 0x71 and not full_message.endswith(self.EOL):
+            full_message += self.EOL
+            full_message = b"\x72" + full_message[1:]
+            was_keyboard_input = True
+        else:
+            was_keyboard_input = False
+
+        if not full_message.endswith(self.EOL):
+            if full_message[0] == 0x65:
+                full_message = self.buffer[:expected_length + 1]
+                if full_message.endswith(self.EOL):
+                    self.buffer = self.buffer[expected_length + 1:]
+                    return full_message[:-3], was_keyboard_input
+
+            msg, kb_from_var = self._extract_varied_length_packet()
+            if msg is None:
+                # propagate any keyboard flag we might have gotten
+                return None, was_keyboard_input or kb_from_var
+
+            self.dropped_buffer += msg + self.EOL
+            return self._extract_packet()
+
+        self.buffer = self.buffer[expected_length:]
+        if self.buffer.startswith(self.EOL):
+            self.buffer = self.buffer[3:]
+            was_keyboard_input = False
+
+        return full_message[:-3], was_keyboard_input
 
     def _extract_varied_length_packet(self):
         """Extract a varied-length packet from the buffer."""

From 70c542e45def1979354495afa5bd40468ce0033e Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 21:55:27 +0000
Subject: [PATCH 16/19] Refactor data_received_number test case

Update test for data_received_number to handle EOL bytes.
---
 tests/tjc_test.py | 14 ++++++++++----
 1 file changed, 10 insertions(+), 4 deletions(-)

diff --git a/tests/tjc_test.py b/tests/tjc_test.py
index 9106c9d..b6eb569 100644
--- a/tests/tjc_test.py
+++ b/tests/tjc_test.py
@@ -10,19 +10,25 @@ def test_is_event():
     assert protocol.is_event(b"\x71") is False
     assert protocol.is_event(b"\x72") is True
 
-
 def test_data_received_touch_event():
     m = MagicMock()
     protocol = TJCProtocol(m)
     protocol.data_received(b"\x65\xF1\x02\xFF\xFF\xFF\xFF")
     m.assert_called_once_with(b"\x65\xF1\x02")
 
-
 def test_data_received_number():
     m = MagicMock()
     protocol = TJCProtocol(m)
-    protocol.data_received(b"\x72\xF1\x02\x03\x05\x04\xFF\xFF\xFF")
-    m.assert_called_once_with(b"\x72\xF1\x02\x03\x05\x04")
+    # 0x72 packet: 1 header + 2 (page, component) + 2 (value) + 3 EOL = 8 bytes total
+    protocol.data_received(b"\x72\xF1\x02\x03\x05\xFF\xFF\xFF")
+    # Handler should see the message without the EOL bytes
+    m.assert_called_once_with(b"\x72\xF1\x02\x03\x05")
+
+#def test_data_received_number():
+#    m = MagicMock()
+#    protocol = TJCProtocol(m)
+#    protocol.data_received(b"\x72\xF1\x02\x03\x05\x04\xFF\xFF\xFF")
+#    m.assert_called_once_with(b"\x72\xF1\x02\x03\x05\x04")
 
 
 def test_data_received_number_broken():

From 2750ca9c0b6d0f6c521668b5012f6e605aa76fb6 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 22:03:02 +0000
Subject: [PATCH 17/19] Improve signal handler for graceful shutdown

Refactor signal handler to check if event loop exists before stopping it.
---
 display.py | 14 ++++++--------
 1 file changed, 6 insertions(+), 8 deletions(-)

diff --git a/display.py b/display.py
index 1a5a378..5102a59 100644
--- a/display.py
+++ b/display.py
@@ -67,16 +67,18 @@
 # Global flag for graceful shutdown
 _shutdown_requested = False
 
-# Create module-level logger and event loop early
+# Create module-level logger and placeholder for event loop
 logger = logging.getLogger(__name__)
-loop = asyncio.get_event_loop()
+loop = None
 
 def signal_handler(signum, frame):
-    global _shutdown_requested
+    global _shutdown_requested, loop
     _shutdown_requested = True
     logger.info("Received signal %s, initiating graceful shutdown...", signum)
     try:
-        loop.call_soon_threadsafe(loop.stop)
+        # Only attempt to stop the loop if it exists and is running.
+        if loop is not None and loop.is_running():
+            loop.call_soon_threadsafe(loop.stop)
     except Exception:
         # Log the error instead of swallowing it silently
         logger.exception("Unexpected error in signal_handler")
@@ -85,10 +87,6 @@ def signal_handler(signum, frame):
 signal.signal(signal.SIGTERM, signal_handler)
 signal.signal(signal.SIGINT, signal_handler)
 
-# Register signal handlers
-signal.signal(signal.SIGTERM, signal_handler)
-signal.signal(signal.SIGINT, signal_handler)
-
 log_file = os.path.expanduser("~/printer_data/logs/display_connector.log")
 logger = logging.getLogger(__name__)
 ch_log = logging.StreamHandler(sys.stdout)

From 245bc93e8b12fdc2167e8adb5689265012f6aa12 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 23:43:41 +0000
Subject: [PATCH 18/19] Fix position_max checks for stepper_y and stepper_z

Updated checks for position_max in stepper_y and stepper_z.
---
 display.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/display.py b/display.py
index 5102a59..def1ae3 100644
--- a/display.py
+++ b/display.py
@@ -1478,10 +1478,10 @@ def safe_int_convert(value, default=0):
                 if "position_max" in new_data["config"]["stepper_x"]:
                     max_x = int(float(new_data["config"]["stepper_x"]["position_max"])) #added conversion from float numbers, stripping decimal part
             if "stepper_y" in new_data["config"]:
-                if "position_max" in new_data["config"]["stepper_x"]:
+                if "position_max" in new_data["config"]["stepper_y"]:
                     max_y = int(float(new_data["config"]["stepper_y"]["position_max"])) #added conversion from float numbers, stripping decimal part
             if "stepper_z" in new_data["config"]:
-                if "position_max" in new_data["config"]["stepper_x"]:
+                if "position_max" in new_data["config"]["stepper_z"]:
                     max_z = int(float(new_data["config"]["stepper_z"]["position_max"])) #added conversion from float numbers, stripping decimal part
 
             if max_x > 0 and max_y > 0 and max_z > 0:

From 57b458a58d53fe503fff976700331312ee2cfa57 Mon Sep 17 00:00:00 2001
From: HalfManBear <89969229+halfmanbear@users.noreply.github.com>
Date: Tue, 25 Nov 2025 23:48:24 +0000
Subject: [PATCH 19/19] Refactor write method and command execution

Refactor write method to use _execute_command for command execution and improve blocking logic.
---
 src/communicator.py | 61 +++++++++++++++++++++++++++------------------
 1 file changed, 37 insertions(+), 24 deletions(-)

diff --git a/src/communicator.py b/src/communicator.py
index 606e124..5481b44 100644
--- a/src/communicator.py
+++ b/src/communicator.py
@@ -42,19 +42,8 @@ async def connect(self):
             self.logger.error(f"Failed to connect to display: {str(e)}")
             raise
 
-    async def write(self, data, timeout=None, blocked_key=None):
-        # Fast path: decide blocking under lock
-        async with self._write_lock:
-            # If someone else is blocking, queue this command
-            if self.blocked_by and self.blocked_by != blocked_key:
-                self.blocked_buffer.append((data, timeout))
-                return
-
-            # Claim the block if caller provided a key and none is set
-            if blocked_key and not self.blocked_by:
-                self.blocked_by = blocked_key
-
-        # Execute the command outside the lock
+    async def _execute_command(self, data, timeout=None):
+        """Execute a display command directly without queueing logic."""
         try:
             effective_timeout = self.timeout if timeout is None else timeout
             await asyncio.wait_for(
@@ -70,7 +59,6 @@ async def write(self, data, timeout=None, blocked_key=None):
                 await self.display.reconnect()
             except Exception as e:
                 self.logger.warning(f"Display reconnect failed after timeout: {e}")
-            return
         except CommandFailed as e:
             # Expected if we target a control not present on the current page
             self.logger.debug(
@@ -79,24 +67,49 @@ async def write(self, data, timeout=None, blocked_key=None):
         except Exception as e:
             # Any other error: log and continue
             self.logger.warning(f"Unexpected error writing to display: {e}")
+
+    async def write(self, data, timeout=None, blocked_key=None):
+        # Fast path: decide blocking under lock
+        async with self._write_lock:
+            # If someone else is blocking, queue this command
+            if self.blocked_by and self.blocked_by != blocked_key:
+                self.blocked_buffer.append((data, timeout))
+                return
+
+            # Claim the block if caller provided a key and none is set
+            if blocked_key and not self.blocked_by:
+                self.blocked_by = blocked_key
+
+        # Execute the command outside the lock
+        try:
+            await self._execute_command(data, timeout)
         finally:
             # If this was a blocking op, release block and send the next queued command (if any)
             if blocked_key:
                 await self.unblock(blocked_key)
 
     async def unblock(self, blocked_key):
-        next_item = None
+        # Release the block if we're the current blocker
         async with self._write_lock:
-            if self.blocked_by == blocked_key:
-                self.blocked_by = None
-                if self.blocked_buffer:
-                    # pop the next queued command (FIFO)
+            if self.blocked_by != blocked_key:
+                return
+            self.blocked_by = None
+
+        # Process all queued commands iteratively (avoids recursion)
+        while True:
+            next_item = None
+            async with self._write_lock:
+                # Only process queue if no one else has claimed the block
+                if not self.blocked_by and self.blocked_buffer:
                     next_item = self.blocked_buffer.pop(0)
-
-        # Send the next queued command outside the lock to avoid deadlocks
-        if next_item is not None and self.blocked_by is None:
-            data, timeout = next_item
-            await self.write(data, timeout=timeout)
+                else:
+                    break
+
+            if next_item:
+                data, timeout = next_item
+                await self._execute_command(data, timeout)
+            else:
+                break
         
     def get_device_name(self):
         return self.model