implement plugin system and new read serial feature

Author: Lupin3000

config/application_configuration.py

@@ -1,7 +1,6 @@
 # application settings
 TITLE: str = 'MicroPython Firmware Studio'
 LOG_LEVEL: str = 'INFO'
-SERIAL_RATE: int = 115200
 
 # application colors
 APPEARANCE_MODE: str = 'dark'
@@ -18,3 +17,7 @@
 
 # images
 RELOAD_ICON: str = 'img/reload.png'
+
+# plugin
+SERIAL_RATE: int = 115200
+SERIAL_SECONDS: int = 5

serial_plugin/serial_command_runner.py

@@ -15,7 +15,6 @@ class SerialCommandRunner:
     serial ports, such as version and file structure data.
     """
 
-
     @staticmethod
     def _run_in_thread(worker: Callable[[], str], callback: Callable[[str], None]) -> None:
         """
@@ -42,6 +41,14 @@ def task() -> None:
 
     @staticmethod
     def _run_monitor(port: str) -> str:
+        """
+        Executes a monitor utility for a given port and retrieves debug information.
+
+        :param port: The serial port to connect to.
+        :type port: str
+        :return: The debug information as a string.
+        :rtype: str
+        """
         with Debug(port=port) as monitor:
             return monitor.get_debug()
 
@@ -72,6 +79,16 @@ def _get_structure(port: str) -> str:
             return structure_fetcher.get_tree()
 
     def get_debug(self, port: str, callback: Callable[[str], None]) -> None:
+        """
+        Invokes a debug process in a separate thread. The function runs a monitoring
+        process for the provided port and applies the specified callback upon completion.
+
+        :param port: The serial port to connect to.
+        :type port: str
+        :param callback: The function to be executed with the result.
+        :type callback: Callable[[str], None]
+        :return: None
+        """
         self._run_in_thread(lambda: self._run_monitor(port), callback)
 
     def get_version(self, port: str, callback: Callable[[str], None]) -> None:

serial_plugin/serial_monitor.py

@@ -1,5 +1,7 @@
-from logging import getLogger, debug
+from logging import getLogger, debug, error
+from time import time
 from .serial_base import SerialBase
+from config.application_configuration import SERIAL_SECONDS
 
 
 logger = getLogger(__name__)
@@ -8,13 +10,32 @@
 class Debug(SerialBase):
     """
     Represents a utility for interacting with a device to fetch the
-    current console over a serial connection.
+    current console output over a serial connection for specific time.
     """
-    pass
 
-    def get_debug(self) -> str:
-        while True:
-            line = self._ser.readline().decode('utf-8', errors='ignore').strip()
+    def get_debug(self, seconds: int = SERIAL_SECONDS) -> str:
+        """
+        Retrieves debug information from a serial connection over a fixed period.
 
-            if line:
-                debug(line)
+        :param seconds: The number of seconds to wait for debug information.
+        :type seconds: int
+        :return: The debug information as a string.
+        :rtype: str
+        """
+        debug(f"read debug for {seconds} sec")
+        output = []
+        start_time = time()
+        end_time = start_time + seconds
+
+        while time() < end_time:
+            try:
+                if self._ser.in_waiting:
+                    line = self._ser.readline().decode('utf-8', errors='ignore').strip()
+                    if line:
+                        debug(line)
+                        output.append(line)
+            except Exception as e:
+                error(e)
+                break
+
+        return "\n".join(output)

ui/__init__.py

@@ -10,7 +10,7 @@
 
 __all__ = ["BaseUI",
            "CommandRunner",
-            "FrameConsole",
+           "FrameConsole",
            "FrameSearchDevice",
            "FrameDeviceInformation",
            "FrameEraseDevice",

ui/firmware_studio.py

@@ -2,10 +2,11 @@
 from serial.tools import list_ports
 from logging import getLogger, debug, info, error
 from os.path import expanduser
+from customtkinter import CTkButton, CTkFrame
 from tkinter import filedialog, Event
 from webbrowser import open_new
-from typing import Optional, Callable
 from queue import Queue, Empty
+from typing import Optional, Callable, Tuple
 from ui.base_ui import BaseUI
 from ui.frame_device_information import FrameDeviceInformation
 from ui.frame_erase_device import FrameEraseDevice
@@ -16,8 +17,6 @@
 from esptool_plugin.esptool_command_runner import CommandRunner
 from serial_plugin.serial_command_runner import SerialCommandRunner
 from config.device_configuration import BAUDRATE_OPTIONS, DEFAULT_URL, CONFIGURED_DEVICES
-from config.application_configuration import (FONT_PATH, FONT_CATEGORY, FONT_DESCRIPTION, CONSOLE_INFO,
-                                              CONSOLE_COMMAND, CONSOLE_ERROR)
 
 
 logger = getLogger(__name__)
@@ -55,74 +54,62 @@ def __init__(self):
         debug('Adding frames to UI and configuring elements')
         # Search Device
         self.search_device = FrameSearchDevice(self)
-        self.search_device.label.configure(font=FONT_PATH)
         self.search_device.reload_btn.configure(command=self._search_devices)
         self.search_device.device_option.configure(command=self._set_device)
 
         # Device Information
         self.information = FrameDeviceInformation(self)
-        self.information.label.configure(font=FONT_CATEGORY)
+
         self.information.chip_info_btn.configure(command=lambda: self._esptool_command("chip_id"))
         self.information.memory_info_btn.configure(command=lambda: self._esptool_command("flash_id"))
         self.information.mac_info_btn.configure(command=lambda: self._esptool_command("read_mac"))
-        self.information.mac_info_btn.pack_forget()
         self.information.flash_status_btn.configure(command=lambda: self._esptool_command("read_flash_status"))
+
+        self.information.mac_info_btn.pack_forget()
         self.information.flash_status_btn.pack_forget()
 
         # PlugIns
         self.plugins = FramePlugIns(self)
-        self.plugins.label.configure(font=FONT_CATEGORY)
-        # self.plugins.mp_debug_btn.configure(command=self._debug_device)
+
+        self.plugins.mp_debug_btn.configure(command=self._handler_toplevel_serial_debug)
         self.plugins.mp_version_btn.configure(command=self._get_version)
-        self.plugins.mp_version_btn.pack_forget()
         self.plugins.mp_structure_btn.configure(command=self._get_structure)
+
+        self.plugins.mp_version_btn.pack_forget()
         self.plugins.mp_structure_btn.pack_forget()
 
         # Erase Device
         self.erase_device = FrameEraseDevice(self)
-        self.erase_device.label.configure(font=FONT_CATEGORY)
         self.erase_device.erase_btn.configure(command=lambda: self._esptool_command("erase_flash"))
 
         # Flash Firmware
         self.flash_firmware = FrameFirmwareFlash(self)
-        self.flash_firmware.label.configure(font=FONT_CATEGORY)
+
         self.flash_firmware.expert_mode.configure(command=self.toggle_expert_mode)
-        self.flash_firmware.chip_option.set("Select Chip")
         self.flash_firmware.chip_option.configure(command=self._set_chip)
-        self.flash_firmware.chip_info.configure(font=FONT_DESCRIPTION)
         self.flash_firmware.firmware_btn.configure(command=self._handle_firmware_selection)
-        self.flash_firmware.link_label.configure(font=(*FONT_DESCRIPTION, "underline"))
         self.flash_firmware.link_label.bind("<Button-1>", self.open_url)
-        self.flash_firmware.firmware_info.configure(font=FONT_DESCRIPTION)
         self.flash_firmware.baudrate_option.set(str(self.__selected_baudrate))
         self.flash_firmware.baudrate_option.configure(command=self._set_baudrate)
         self.flash_firmware.baudrate_checkbox.select()
-        self.flash_firmware.baudrate_info.configure(font=FONT_DESCRIPTION)
         self.flash_firmware.sector_input.bind("<KeyRelease>", self._handle_sector_input)
-        self.flash_firmware.sector_info.configure(font=FONT_DESCRIPTION)
+        self.flash_firmware.flash_btn.configure(command=self._flash_firmware_command)
+
         self.flash_firmware.flash_mode_label.grid_remove()
-        self.flash_firmware.flash_mode_option.set("keep")
         self.flash_firmware.flash_mode_option.grid_remove()
         self.flash_firmware.flash_mode_info.grid_remove()
         self.flash_firmware.flash_frequency_label.grid_remove()
-        self.flash_firmware.flash_frequency_option.set("keep")
         self.flash_firmware.flash_frequency_option.grid_remove()
         self.flash_firmware.flash_frequency_info.grid_remove()
         self.flash_firmware.flash_size_label.grid_remove()
-        self.flash_firmware.flash_size_option.set("detect")
         self.flash_firmware.flash_size_option.grid_remove()
         self.flash_firmware.flash_size_info.grid_remove()
         self.flash_firmware.erase_before_label.grid_remove()
         self.flash_firmware.erase_before_switch.grid_remove()
         self.flash_firmware.erase_before_info.grid_remove()
-        self.flash_firmware.flash_btn.configure(command=self._flash_firmware_command)
 
         # Console
         self.console = FrameConsole(self)
-        self.console.label.configure(font=FONT_CATEGORY)
-        self.console.console_text.tag_config("info", foreground=CONSOLE_INFO)
-        self.console.console_text.tag_config("normal", foreground=CONSOLE_COMMAND)
-        self.console.console_text.tag_config("error", foreground=CONSOLE_ERROR)
         self.console.console_text.bind("<Key>", BaseUI._block_text_input)
 
         debug('Searching for USB devices')
@@ -226,31 +213,35 @@ def _disable_buttons(self) -> None:
 
         :return: None
         """
-        self.information.chip_info_btn.configure(state='disabled')
-        self.information.memory_info_btn.configure(state='disabled')
-        self.information.mac_info_btn.configure(state='disabled')
-        self.information.flash_status_btn.configure(state='disabled')
-        # self.plugins.mp_debug_btn.configure(state='disabled')
-        self.plugins.mp_version_btn.configure(state='disabled')
-        self.plugins.mp_structure_btn.configure(state='disabled')
-        self.erase_device.erase_btn.configure(state='disabled')
-        self.flash_firmware.flash_btn.configure(state='disabled')
+        frames: Tuple[CTkFrame, ...] = (self.information, self.plugins, self.erase_device, self.flash_firmware)
+
+        buttons = [
+            widget
+            for frame in frames if isinstance(frame, CTkFrame)
+            for widget in frame.winfo_children()
+            if isinstance(widget, CTkButton)
+        ]
+
+        for button in buttons:
+            button.configure(state='disabled')
 
     def _enable_buttons(self) -> None:
         """
         Enables specific UI buttons by changing their state to 'normal'.
 
         :return: None
         """
-        self.information.chip_info_btn.configure(state='normal')
-        self.information.memory_info_btn.configure(state='normal')
-        self.information.mac_info_btn.configure(state='normal')
-        self.information.flash_status_btn.configure(state='normal')
-        # self.plugins.mp_debug_btn.configure(state='normal')
-        self.plugins.mp_version_btn.configure(state='normal')
-        self.plugins.mp_structure_btn.configure(state='normal')
-        self.erase_device.erase_btn.configure(state='normal')
-        self.flash_firmware.flash_btn.configure(state='normal')
+        frames: Tuple[CTkFrame, ...] = (self.information, self.plugins, self.erase_device, self.flash_firmware)
+
+        buttons = [
+            widget
+            for frame in frames if isinstance(frame, CTkFrame)
+            for widget in frame.winfo_children()
+            if isinstance(widget, CTkButton)
+        ]
+
+        for button in buttons:
+            button.configure(state='normal')
 
     def _search_devices(self) -> None:
         """
@@ -416,8 +407,19 @@ def _run_serial_task(self, info_text: str, command: Callable[[SerialCommandRunne
         runner = SerialCommandRunner()
         command(runner)
 
-    def _debug_device(self) -> None:
-        pass
+    def _handler_toplevel_serial_debug(self) -> None:
+        """
+        Handles the creation or focus of a top-level debug window.
+
+        :return: None
+        """
+        self._run_serial_task(
+            info_text="Start Serial debugging",
+            command=lambda runner: runner.get_debug(
+                port=self.__device_path,
+                callback=lambda output: self._handle_serial_output(output)
+            )
+        )
 
     def _get_version(self) -> None:
         """

ui/frame_console.py

@@ -1,5 +1,7 @@
 from logging import getLogger, debug
 from customtkinter import CTkFrame, CTkLabel, CTkTextbox
+from config.application_configuration import FONT_CATEGORY
+from config.application_configuration import CONSOLE_INFO, CONSOLE_COMMAND, CONSOLE_ERROR
 
 
 logger = getLogger(__name__)
@@ -24,6 +26,10 @@ def __init__(self, master, *args, **kwargs):
 
         self.label = CTkLabel(self, text='Console Output')
         self.label.pack(padx=10, pady=10)
+        self.label.configure(font=FONT_CATEGORY)
 
         self.console_text = CTkTextbox(self, width=800, height=300)
         self.console_text.pack(padx=10, pady=10, fill="both", expand=True)
+        self.console_text.tag_config("info", foreground=CONSOLE_INFO)
+        self.console_text.tag_config("normal", foreground=CONSOLE_COMMAND)
+        self.console_text.tag_config("error", foreground=CONSOLE_ERROR)

ui/frame_device_information.py

@@ -1,5 +1,6 @@
 from logging import getLogger, debug
 from customtkinter import CTkFrame, CTkLabel, CTkButton
+from config.application_configuration import FONT_CATEGORY
 
 
 logger = getLogger(__name__)
@@ -24,6 +25,7 @@ def __init__(self, master, *args, **kwargs):
 
         self.label = CTkLabel(self, text='Information')
         self.label.pack(padx=10, pady=10)
+        self.label.configure(font=FONT_CATEGORY)
 
         self.chip_info_btn = CTkButton(self, text='Chip ID')
         self.chip_info_btn.pack(padx=10, pady=5)

ui/frame_erase_device.py

@@ -1,5 +1,6 @@
 from logging import getLogger, debug
 from customtkinter import CTkFrame, CTkLabel, CTkButton
+from config.application_configuration import FONT_CATEGORY
 
 
 logger = getLogger(__name__)
@@ -24,6 +25,7 @@ def __init__(self, master, *args, **kwargs):
 
         self.label = CTkLabel(self, text='Erase')
         self.label.pack(padx=10, pady=10)
+        self.label.configure(font=FONT_CATEGORY)
 
         self.erase_btn = CTkButton(self, text='Erase Flash')
         self.erase_btn.pack(padx=10, pady=5)