Use the toggle buttons above to select which views to display:
" + "WatchView: Monitor and modify variable values in real-time.
"
+ "Add variables, set scaling/offset, and write values directly.
ScopeView: Capture and visualize variable waveforms.
"
+ "Configure trigger settings and sample multiple channels.
Select both buttons to display a split view.
" + ) + instruction_label.setAlignment(Qt.AlignCenter) + instruction_label.setWordWrap(True) + instruction_label.setStyleSheet("color: #666; padding: 40px;") + instruction_layout.addWidget(instruction_label) + + # Splitter for combined view (horizontal for better usability) + self._view_splitter = QSplitter(Qt.Horizontal) + self._view_splitter.addWidget(self._watch_view_tab) + self._view_splitter.addWidget(self._scope_view_tab) + self._view_splitter.setStretchFactor(0, 1) # 50/50 split + self._view_splitter.setStretchFactor(1, 1) + + data_views_layout.addWidget(self._instruction_widget) + data_views_layout.addWidget(self._view_splitter) + + self._tab_widget.addTab(self._data_views_tab, "Data Views") + + # Tab 3: Scripting + self._scripting_tab = ScriptingTab(self._app_state, self) + self._tab_widget.addTab(self._scripting_tab, "Scripting") + + # Set initial view (Both selected) + self._on_view_toggle_changed() + + # Window properties + self.setWindowTitle(f"pyX2Cscope - v{pyx2cscope.__version__}") + icon_path = os.path.join(os.path.dirname(img_src.__file__), "pyx2cscope.jpg") + if os.path.exists(icon_path): + self.setWindowIcon(QtGui.QIcon(icon_path)) + + # Restore window state from settings + self._restore_window_state() + + def _setup_connections(self): + """Set up signal/slot connections.""" + # Connection manager signals + self._connection_manager.connection_changed.connect(self._on_connection_changed) + self._connection_manager.error_occurred.connect(self._show_error) + self._connection_manager.ports_refreshed.connect(self._on_ports_refreshed) + + # App state signals + self._app_state.connection_changed.connect(self._on_connection_changed) + self._app_state.variable_list_updated.connect(self._on_variable_list_updated) + + # Data poller signals + self._data_poller.scope_data_ready.connect(self._scope_view_tab.on_scope_data_ready) + self._data_poller.live_var_updated.connect(self._watch_view_tab.on_live_var_updated) + self._data_poller.error_occurred.connect(self._show_error) + + # Config manager signals + self._config_manager.error_occurred.connect(self._show_error) + + # Setup tab signals + self._setup_tab.connect_requested.connect(self._on_connect_clicked) + self._setup_tab.elf_file_selected.connect(self._on_elf_file_selected) + self._setup_tab.refresh_btn.clicked.connect(self._refresh_ports) + + # Tab polling control signals -> DataPoller + self._scope_view_tab.scope_sampling_changed.connect(self._on_scope_sampling_changed) + self._watch_view_tab.live_polling_changed.connect(self._on_live_watch_changed) + + def _refresh_ports(self): + """Refresh available COM ports.""" + self._connection_manager.refresh_ports() + + def _on_ports_refreshed(self, ports: list): + """Handle ports refreshed signal.""" + self._setup_tab.set_ports(ports) + + def _on_elf_file_selected(self, file_path: str): + """Handle ELF file selection from setup tab.""" + self._settings.setValue("elf_file_path", file_path) + + def _on_connect_clicked(self): + """Handle connect button click.""" + elf_path = self._setup_tab.elf_file_path + if not elf_path: + # Try to load from settings + elf_path = self._settings.value("elf_file_path", "", type=str) + if elf_path: + self._setup_tab.elf_file_path = elf_path + + if not elf_path: + self._setup_tab.set_loading(False) + self._show_error("Please select an ELF file first.") + return + + # Get connection parameters based on selected interface + conn_params = self._setup_tab.get_connection_params() + + # Process events to show loading indicator before blocking operation + QApplication.processEvents() + + connected = self._connection_manager.toggle_connection( + elf_path, **conn_params + ) + + if connected: + self._setup_tab.set_connected(True) + self._setup_tab.save_connection_settings() + self._update_device_info() + else: + self._setup_tab.set_connected(False) + + def _on_connection_changed(self, connected: bool): + """Handle connection state change.""" + self._setup_tab.set_connected(connected) + + # Update tabs + self._scope_view_tab.on_connection_changed(connected) + self._watch_view_tab.on_connection_changed(connected) + self._scripting_tab.on_connection_changed(connected) + + if connected: + self._update_device_info() + else: + self._clear_device_info() + + def _on_variable_list_updated(self, variables: list): + """Handle variable list update.""" + self._scope_view_tab.on_variable_list_updated(variables) + self._watch_view_tab.on_variable_list_updated(variables) + + def _on_view_toggle_changed(self): + """Handle view toggle button changes.""" + watch_selected = self._watch_view_btn.isChecked() + scope_selected = self._scope_view_btn.isChecked() + + if watch_selected and scope_selected: + # Both views - show splitter with both + self._instruction_widget.hide() + self._view_splitter.show() + self._watch_view_tab.show() + self._scope_view_tab.show() + elif watch_selected: + # Only WatchView + self._instruction_widget.hide() + self._view_splitter.show() + self._watch_view_tab.show() + self._scope_view_tab.hide() + elif scope_selected: + # Only ScopeView + self._instruction_widget.hide() + self._view_splitter.show() + self._watch_view_tab.hide() + self._scope_view_tab.show() + else: + # No view selected - show instruction screen + self._view_splitter.hide() + self._instruction_widget.show() + + def _on_scope_sampling_changed(self, is_sampling: bool, is_single_shot: bool): + """Handle scope sampling state change (Tab2).""" + self._data_poller.set_scope_polling_enabled(is_sampling, is_single_shot) + + def _on_live_watch_changed(self, index: int, is_live: bool): + """Handle live watch variable polling state change (Tab3).""" + if is_live: + self._data_poller.add_active_live_index(index) + else: + self._data_poller.remove_active_live_index(index) + + def _update_device_info(self): + """Update device info labels.""" + device_info = self._app_state.update_device_info() + self._setup_tab.update_device_info(device_info) + + def _clear_device_info(self): + """Clear device info labels.""" + self._setup_tab.clear_device_info() + + def _save_config(self): + """Save current configuration.""" + # Determine view mode from toggle buttons + watch_on = self._watch_view_btn.isChecked() + scope_on = self._scope_view_btn.isChecked() + if watch_on and scope_on: + view_mode = "Both" + elif watch_on: + view_mode = "WatchView" + elif scope_on: + view_mode = "ScopeView" + else: + view_mode = "None" + + # Get connection parameters + conn_params = self._setup_tab.get_connection_params() + + config = ConfigManager.build_config( + elf_file=self._setup_tab.elf_file_path, + connection=conn_params, + scope_view=self._scope_view_tab.get_config(), + tab3_view=self._watch_view_tab.get_config(), + view_mode=view_mode, + ) + self._config_manager.save_config(config) + + def _load_config(self): # noqa: PLR0912, PLR0915 + """Load configuration from file.""" + config = self._config_manager.load_config() + if not config: + return + + # Load ELF file + elf_path = config.get("elf_file", "") + if elf_path: + if self._config_manager.validate_elf_file(elf_path): + self._setup_tab.elf_file_path = elf_path + else: + self._config_manager.show_file_not_found_warning(elf_path) + new_path = self._config_manager.prompt_for_elf_file() + if new_path: + self._setup_tab.elf_file_path = new_path + + # Load connection settings (new format with interface support) + conn_params = config.get("connection", {}) + if conn_params: + self._setup_tab.set_connection_params(conn_params) + + # For UART, also set the port if available + if conn_params.get("interface") == "UART": + com_port = conn_params.get("port", "") + port_combo = self._setup_tab.port_combo + if com_port and com_port in [port_combo.itemText(i) for i in range(port_combo.count())]: + port_combo.setCurrentText(com_port) + else: + # Legacy config format support + baud_rate = config.get("baud_rate", "115200") + self._setup_tab.baud_combo.setCurrentText(baud_rate) + com_port = config.get("com_port", "") + port_combo = self._setup_tab.port_combo + if com_port and com_port in [port_combo.itemText(i) for i in range(port_combo.count())]: + port_combo.setCurrentText(com_port) + + # Try to connect (only if not already connected) + if self._setup_tab.elf_file_path and not self._app_state.is_connected(): + self._on_connect_clicked() + + # Load tab configurations + self._scope_view_tab.load_config(config.get("scope_view", {})) + self._watch_view_tab.load_config(config.get("tab3_view", {})) + + # Load view mode and set toggle buttons + view_mode = config.get("view_mode", "Both") + if view_mode == "Both": + self._watch_view_btn.setChecked(True) + self._scope_view_btn.setChecked(True) + elif view_mode == "WatchView": + self._watch_view_btn.setChecked(True) + self._scope_view_btn.setChecked(False) + elif view_mode == "ScopeView": + self._watch_view_btn.setChecked(False) + self._scope_view_btn.setChecked(True) + else: # None + self._watch_view_btn.setChecked(False) + self._scope_view_btn.setChecked(False) + self._on_view_toggle_changed() + + # Re-enable widgets after loading config (for dynamically created widgets) + is_connected = self._app_state.is_connected() + if is_connected: + self._scope_view_tab.on_connection_changed(True) + self._watch_view_tab.on_connection_changed(True) + + # Also ensure variable list is populated in tabs + variables = self._app_state.get_variable_list() + if variables: + self._scope_view_tab.on_variable_list_updated(variables) + self._watch_view_tab.on_variable_list_updated(variables) + + # Activate polling for any live checkboxes that were loaded as checked + self._activate_loaded_polling() + + def _activate_loaded_polling(self): + """Activate polling for any live checkboxes that were loaded as checked.""" + # WatchView tab - check live checkboxes + for i, cb in enumerate(self._watch_view_tab._live_checkboxes): + if cb.isChecked(): + self._data_poller.add_active_live_index(i) + + def _show_error(self, message: str): + """Show error message to user.""" + logging.error(message) + QMessageBox.critical(self, "Error", message) + + def _save_window_state(self): + """Save window geometry and state to settings.""" + self._settings.setValue("window/geometry", self.saveGeometry()) + self._settings.setValue("window/state", self.saveState()) + self._settings.setValue("window/splitter_sizes", self._view_splitter.sizes()) + self._settings.setValue("window/watch_view_checked", self._watch_view_btn.isChecked()) + self._settings.setValue("window/scope_view_checked", self._scope_view_btn.isChecked()) + self._settings.setValue("window/current_tab", self._tab_widget.currentIndex()) + + def _restore_window_state(self): + """Restore window geometry and state from settings.""" + # Restore window geometry + geometry = self._settings.value("window/geometry") + if geometry: + self.restoreGeometry(geometry) + + # Restore window state + state = self._settings.value("window/state") + if state: + self.restoreState(state) + + # Restore splitter sizes + splitter_sizes = self._settings.value("window/splitter_sizes") + if splitter_sizes: + # Convert to list of ints if needed + if isinstance(splitter_sizes, list): + sizes = [int(s) for s in splitter_sizes] + self._view_splitter.setSizes(sizes) + + # Restore toggle button states + watch_checked = self._settings.value("window/watch_view_checked", False, type=bool) + scope_checked = self._settings.value("window/scope_view_checked", False, type=bool) + self._watch_view_btn.setChecked(watch_checked) + self._scope_view_btn.setChecked(scope_checked) + self._on_view_toggle_changed() + + # Always start on Setup tab + self._tab_widget.setCurrentIndex(0) + + def closeEvent(self, event): # noqa: N802 + """Handle window close event.""" + # Save window state before closing + self._save_window_state() + + # Stop data poller + self._data_poller.stop() + + # Disconnect if connected + if self._connection_manager.is_connected(): + self._connection_manager.disconnect() + + event.accept() + + +def execute_qt(): + """Entry point for the Qt application.""" + import sys + + from PyQt5.QtWidgets import QApplication + + app = QApplication(sys.argv) + window = MainWindow() + window.show() + sys.exit(app.exec_()) + + +if __name__ == "__main__": + execute_qt() diff --git a/pyx2cscope/gui/qt/models/__init__.py b/pyx2cscope/gui/qt/models/__init__.py new file mode 100644 index 00000000..728feb78 --- /dev/null +++ b/pyx2cscope/gui/qt/models/__init__.py @@ -0,0 +1,5 @@ +"""Data models for the generic GUI.""" + +from .app_state import AppState, ScopeChannel, TriggerSettings, WatchVariable + +__all__ = ["AppState", "WatchVariable", "ScopeChannel", "TriggerSettings"] diff --git a/pyx2cscope/gui/qt/models/app_state.py b/pyx2cscope/gui/qt/models/app_state.py new file mode 100644 index 00000000..9f70f135 --- /dev/null +++ b/pyx2cscope/gui/qt/models/app_state.py @@ -0,0 +1,793 @@ +"""Centralized application state management. + +This module provides thread-safe state management for the generic GUI, +inspired by the WebScope pattern from the web GUI. +""" + +import logging +from collections import deque +from dataclasses import dataclass, field +from typing import Any, Dict, List, Optional + +from PyQt5.QtCore import QMutex, QObject, pyqtSignal + +from pyx2cscope.x2cscope import TriggerConfig, X2CScope + + +@dataclass +class WatchVariable: + """Represents a watch variable configuration.""" + + name: str = "" + value: float = 0.0 + scaling: float = 1.0 + offset: float = 0.0 + unit: str = "" + live: bool = False + plot_enabled: bool = False + sfr: bool = False # True when the variable is a Special Function Register + _var_ref: Any = field(default=None, repr=False) # Cached x2cscope variable reference + + @property + def scaled_value(self) -> float: + """Calculate the scaled value.""" + return (self.value * self.scaling) + self.offset + + @property + def var_ref(self): + """Get the cached x2cscope variable reference.""" + return self._var_ref + + @var_ref.setter + def var_ref(self, value): + """Set the cached x2cscope variable reference.""" + self._var_ref = value + + +@dataclass +class ScopeChannel: + """Represents a scope channel configuration.""" + + name: str = "" + trigger: bool = False + gain: float = 1.0 + visible: bool = True + sfr: bool = False # True when the variable is a Special Function Register + + +@dataclass +class TriggerSettings: + """Trigger configuration settings.""" + + mode: str = "Auto" # "Auto" or "Triggered" + edge: str = "Rising" # "Rising" or "Falling" + level: float = 0.0 + delay: int = 0 + variable: Optional[str] = None + + +@dataclass +class DeviceInfo: + """Device information.""" + + processor_id: str = "" + uc_width: str = "" + date: str = "" + time: str = "" + app_ver: str = "" + dsp_state: str = "" + + +class AppState(QObject): + """Centralized application state management. + + Provides thread-safe access to all application state including: + - Connection status and device info + - Watch variables (Tab1 and Tab3) + - Scope channels and trigger settings (Tab2) + - Plot data accumulation + + Similar to WebScope in the web GUI, this class uses a mutex + to ensure thread-safe operations. + """ + + # Signals for state changes + connection_changed = pyqtSignal(bool) + device_info_updated = pyqtSignal(dict) + variable_list_updated = pyqtSignal(list) + + MAX_WATCH_VARS = 5 + MAX_SCOPE_CHANNELS = 8 + PLOT_DATA_MAXLEN = 250 + + def __init__(self, parent=None): + """Initialize the application state.""" + super().__init__(parent) + self._mutex = QMutex() + self._x2cscope: Optional[X2CScope] = None + + # Connection state + self._port: str = "" + self._baud_rate: int = 115200 + self._elf_file: str = "" + self._connected: bool = False + + # Device info + self._device_info = DeviceInfo() + + # Variable list cache + self._variable_list: List[str] = [] + + # Watch variables (Tab1 - WatchPlot) + self._watch_vars: List[WatchVariable] = [ + WatchVariable() for _ in range(self.MAX_WATCH_VARS) + ] + + # Scope channels (Tab2 - ScopeView) + self._scope_channels: List[ScopeChannel] = [ + ScopeChannel() for _ in range(self.MAX_SCOPE_CHANNELS) + ] + + # Trigger settings + self._trigger_settings = TriggerSettings() + + # Scope state + self._scope_active: bool = False + self._scope_single_shot: bool = False + self._sample_time_factor: int = 1 + self._scope_sample_time_us: int = 50 + self._real_sample_time: float = 0.0 + + # Dynamic watch variables (Tab3 - WatchView) + self._live_watch_vars: List[WatchVariable] = [] + + # Plot data accumulator + self._plot_data: deque = deque(maxlen=self.PLOT_DATA_MAXLEN) + + # Timing configuration + self._watch_poll_interval_ms: int = 500 + + # ============= Connection Management ============= + + @property + def x2cscope(self) -> Optional[X2CScope]: + """Get X2CScope instance (not thread-safe, use with caution).""" + return self._x2cscope + + def set_x2cscope(self, x2cscope: Optional[X2CScope]): + """Set the X2CScope instance (thread-safe).""" + self._mutex.lock() + try: + self._x2cscope = x2cscope + if x2cscope: + self._variable_list = x2cscope.list_variables() or [] + if self._variable_list: + self._variable_list.insert(0, "None") + self._connected = True + else: + self._variable_list = [] + self._connected = False + finally: + self._mutex.unlock() + self.connection_changed.emit(self._connected) + self.variable_list_updated.emit(self._variable_list) + + def is_connected(self) -> bool: + """Check if connected to device (thread-safe).""" + self._mutex.lock() + try: + return self._connected and self._x2cscope is not None + finally: + self._mutex.unlock() + + def get_variable_list(self) -> List[str]: + """Get cached variable list (thread-safe).""" + self._mutex.lock() + try: + return self._variable_list.copy() + finally: + self._mutex.unlock() + + def get_sfr_list(self) -> List[str]: + """Get the list of SFR (Special Function Register) names (thread-safe).""" + self._mutex.lock() + try: + if self._x2cscope: + return self._x2cscope.list_sfr() + return [] + finally: + self._mutex.unlock() + + def update_device_info(self) -> Optional[DeviceInfo]: + """Fetch and update device info (thread-safe).""" + self._mutex.lock() + try: + if not self._x2cscope: + return None + info = self._x2cscope.get_device_info() + self._device_info = DeviceInfo( + processor_id=str(info.get("processor_id", "")), + uc_width=str(info.get("uc_width", "")), + date=str(info.get("date", "")), + time=str(info.get("time", "")), + app_ver=str(info.get("AppVer", "")), + dsp_state=str(info.get("dsp_state", "")), + ) + return self._device_info + except Exception as e: + logging.error(f"Error fetching device info: {e}") + return None + finally: + self._mutex.unlock() + + def get_device_info(self) -> DeviceInfo: + """Get cached device info (thread-safe).""" + self._mutex.lock() + try: + return self._device_info + finally: + self._mutex.unlock() + + # ============= Connection Properties ============= + + @property + def port(self) -> str: + """Get the current port.""" + return self._port + + @port.setter + def port(self, value: str): + self._mutex.lock() + self._port = value + self._mutex.unlock() + + @property + def baud_rate(self) -> int: + """Get the current baud rate.""" + return self._baud_rate + + @baud_rate.setter + def baud_rate(self, value: int): + self._mutex.lock() + self._baud_rate = value + self._mutex.unlock() + + @property + def elf_file(self) -> str: + """Get the current ELF file path.""" + return self._elf_file + + @elf_file.setter + def elf_file(self, value: str): + self._mutex.lock() + self._elf_file = value + self._mutex.unlock() + + # ============= Variable Read/Write ============= + + def read_variable(self, name: str, sfr: bool = False) -> Optional[float]: + """Read a variable value from the device (thread-safe). + + Args: + name: The variable name to read. + sfr: When True, look up the name in the SFR register map. + """ + if not name or name == "None": + return None + self._mutex.lock() + try: + if self._x2cscope: + var = self._x2cscope.get_variable(name, sfr=sfr) + if var is not None: + return var.get_value() + except Exception as e: + logging.error(f"Error reading variable {name}: {e}") + finally: + self._mutex.unlock() + return None + + def read_watch_var_value(self, index: int) -> Optional[float]: + """Read a watch variable value using cached var_ref (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._watch_vars): + watch_var = self._watch_vars[index] + if watch_var.var_ref is not None: + return watch_var.var_ref.get_value() + elif watch_var.name and watch_var.name != "None" and self._x2cscope: + # Fallback: get and cache the variable + var_ref = self._x2cscope.get_variable(watch_var.name) + if var_ref is not None: + watch_var.var_ref = var_ref + return var_ref.get_value() + except Exception as e: + logging.error(f"Error reading watch var {index}: {e}") + finally: + self._mutex.unlock() + return None + + def read_live_watch_var_value(self, index: int) -> Optional[float]: + """Read a live watch variable value using cached var_ref (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._live_watch_vars): + live_var = self._live_watch_vars[index] + if live_var.var_ref is not None: + return live_var.var_ref.get_value() + elif live_var.name and live_var.name != "None" and self._x2cscope: + # Fallback: get and cache the variable + var_ref = self._x2cscope.get_variable(live_var.name) + if var_ref is not None: + live_var.var_ref = var_ref + return var_ref.get_value() + except Exception as e: + logging.error(f"Error reading live watch var {index}: {e}") + finally: + self._mutex.unlock() + return None + + def write_variable(self, name: str, value: float, sfr: bool = False) -> bool: + """Write a variable value to the device (thread-safe). + + Args: + name: The variable name to write. + value: The value to write. + sfr: When True, look up the name in the SFR register map. + """ + if not name or name == "None": + return False + self._mutex.lock() + try: + if self._x2cscope: + var = self._x2cscope.get_variable(name, sfr=sfr) + if var is not None: + var.set_value(value) + return True + except Exception as e: + logging.error(f"Error writing variable {name}: {e}") + finally: + self._mutex.unlock() + return False + + # ============= Watch Variables (Tab1) ============= + + def get_watch_var(self, index: int) -> WatchVariable: + """Get watch variable at index (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._watch_vars): + return self._watch_vars[index] + return WatchVariable() + finally: + self._mutex.unlock() + + def set_watch_var(self, index: int, var: WatchVariable): + """Set watch variable at index (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._watch_vars): + self._watch_vars[index] = var + finally: + self._mutex.unlock() + + def update_watch_var_field(self, index: int, field: str, value: Any): + """Update a specific field of a watch variable (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._watch_vars): + setattr(self._watch_vars[index], field, value) + # Cache the x2cscope variable reference when name is set + if field == "name" and value and value != "None" and self._x2cscope: + sfr = self._watch_vars[index].sfr + var_ref = self._x2cscope.get_variable(value, sfr=sfr) + if var_ref is not None: + self._watch_vars[index].var_ref = var_ref + finally: + self._mutex.unlock() + + def get_active_watch_vars(self) -> List[Dict[str, Any]]: + """Get all watch variables with live=True (thread-safe).""" + self._mutex.lock() + try: + return [ + {"index": i, "name": v.name, "live": v.live} + for i, v in enumerate(self._watch_vars) + if v.live and v.name and v.name != "None" + ] + finally: + self._mutex.unlock() + + def get_all_watch_vars(self) -> List[WatchVariable]: + """Get all watch variables (thread-safe copy).""" + self._mutex.lock() + try: + return [ + WatchVariable( + name=v.name, + value=v.value, + scaling=v.scaling, + offset=v.offset, + unit=v.unit, + live=v.live, + plot_enabled=v.plot_enabled, + ) + for v in self._watch_vars + ] + finally: + self._mutex.unlock() + + # ============= Scope Channels (Tab2) ============= + + def get_scope_channel(self, index: int) -> ScopeChannel: + """Get scope channel at index (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._scope_channels): + return self._scope_channels[index] + return ScopeChannel() + finally: + self._mutex.unlock() + + def set_scope_channel(self, index: int, channel: ScopeChannel): + """Set scope channel at index (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._scope_channels): + self._scope_channels[index] = channel + finally: + self._mutex.unlock() + + def update_scope_channel_field(self, index: int, field: str, value: Any): + """Update a specific field of a scope channel (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._scope_channels): + setattr(self._scope_channels[index], field, value) + finally: + self._mutex.unlock() + + def get_all_scope_channels(self) -> List[ScopeChannel]: + """Get all scope channels (thread-safe copy).""" + self._mutex.lock() + try: + return [ + ScopeChannel( + name=c.name, trigger=c.trigger, gain=c.gain, visible=c.visible + ) + for c in self._scope_channels + ] + finally: + self._mutex.unlock() + + def get_trigger_variable(self) -> Optional[str]: + """Get the currently selected trigger variable (thread-safe).""" + self._mutex.lock() + try: + for channel in self._scope_channels: + if channel.trigger and channel.name: + return channel.name + return None + finally: + self._mutex.unlock() + + # ============= Trigger Settings ============= + + def get_trigger_settings(self) -> TriggerSettings: + """Get trigger settings (thread-safe).""" + self._mutex.lock() + try: + return TriggerSettings( + mode=self._trigger_settings.mode, + edge=self._trigger_settings.edge, + level=self._trigger_settings.level, + delay=self._trigger_settings.delay, + variable=self._trigger_settings.variable, + ) + finally: + self._mutex.unlock() + + def set_trigger_settings(self, settings: TriggerSettings): + """Set trigger settings (thread-safe).""" + self._mutex.lock() + try: + self._trigger_settings = settings + finally: + self._mutex.unlock() + + # ============= Scope Operations ============= + + def start_scope(self) -> bool: + """Start scope sampling (thread-safe).""" + self._mutex.lock() + try: + if not self._x2cscope: + return False + + # Clear existing channels + self._x2cscope.clear_all_scope_channel() + + # Add configured channels + for channel in self._scope_channels: + if channel.name and channel.name != "None": + variable = self._x2cscope.get_variable(channel.name, sfr=channel.sfr) + if variable is not None: + self._x2cscope.add_scope_channel(variable) + + # Set sample time + self._x2cscope.set_sample_time(self._sample_time_factor) + self._real_sample_time = self._x2cscope.get_scope_sample_time( + self._scope_sample_time_us + ) + + self._scope_active = True + return True + except Exception as e: + logging.error(f"Error starting scope: {e}") + return False + finally: + self._mutex.unlock() + + def configure_scope_trigger(self) -> bool: + """Configure scope trigger (thread-safe).""" + self._mutex.lock() + try: + if not self._x2cscope: + return False + + trigger_var_name = self.get_trigger_variable() + if self._trigger_settings.mode == "Auto": + self._x2cscope.reset_scope_trigger() + return True + + if trigger_var_name: + # Find sfr flag for the trigger channel + trigger_sfr = next( + (ch.sfr for ch in self._scope_channels if ch.trigger and ch.name == trigger_var_name), + False, + ) + variable = self._x2cscope.get_variable(trigger_var_name, sfr=trigger_sfr) + if variable is not None: + trigger_edge = ( + 0 if self._trigger_settings.edge == "Rising" else 1 + ) + trigger_mode = 1 # Triggered mode + + trigger_config = TriggerConfig( + variable=variable, + trigger_level=self._trigger_settings.level, + trigger_mode=trigger_mode, + trigger_delay=self._trigger_settings.delay, + trigger_edge=trigger_edge, + ) + self._x2cscope.set_scope_trigger(trigger_config) + return True + else: + self._x2cscope.reset_scope_trigger() + return True + except Exception as e: + logging.error(f"Error configuring trigger: {e}") + return False + finally: + self._mutex.unlock() + + def request_scope_data(self): + """Request scope data (thread-safe).""" + self._mutex.lock() + try: + if self._x2cscope: + self._x2cscope.request_scope_data() + finally: + self._mutex.unlock() + + def stop_scope(self): + """Stop scope sampling (thread-safe).""" + self._mutex.lock() + try: + self._scope_active = False + if self._x2cscope: + self._x2cscope.clear_all_scope_channel() + finally: + self._mutex.unlock() + + def is_scope_active(self) -> bool: + """Check if scope is actively sampling (thread-safe).""" + self._mutex.lock() + try: + return self._scope_active + finally: + self._mutex.unlock() + + def is_scope_data_ready(self) -> bool: + """Check if scope data is ready (thread-safe).""" + self._mutex.lock() + try: + if self._x2cscope: + return self._x2cscope.is_scope_data_ready() + except Exception as e: + logging.error(f"Error checking scope data ready: {e}") + finally: + self._mutex.unlock() + return False + + def get_scope_channel_data(self) -> Dict[str, List[float]]: + """Get scope channel data (thread-safe).""" + self._mutex.lock() + try: + if self._x2cscope: + return self._x2cscope.get_scope_channel_data() + except Exception as e: + logging.error(f"Error getting scope data: {e}") + finally: + self._mutex.unlock() + return {} + + # ============= Scope Settings Properties ============= + + @property + def scope_single_shot(self) -> bool: + """Get the scope single shot mode setting.""" + return self._scope_single_shot + + @scope_single_shot.setter + def scope_single_shot(self, value: bool): + self._mutex.lock() + self._scope_single_shot = value + self._mutex.unlock() + + @property + def sample_time_factor(self) -> int: + """Get the sample time factor.""" + return self._sample_time_factor + + @sample_time_factor.setter + def sample_time_factor(self, value: int): + self._mutex.lock() + self._sample_time_factor = value + self._mutex.unlock() + + @property + def scope_sample_time_us(self) -> int: + """Get the scope sample time in microseconds.""" + return self._scope_sample_time_us + + @scope_sample_time_us.setter + def scope_sample_time_us(self, value: int): + self._mutex.lock() + self._scope_sample_time_us = value + self._mutex.unlock() + + @property + def real_sample_time(self) -> float: + """Get the real sample time.""" + return self._real_sample_time + + # ============= Tab3 Live Variables ============= + + def add_live_watch_var(self) -> int: + """Add a new live watch variable row (thread-safe).""" + self._mutex.lock() + try: + self._live_watch_vars.append(WatchVariable()) + return len(self._live_watch_vars) - 1 + finally: + self._mutex.unlock() + + def remove_live_watch_var(self, index: int): + """Remove a live watch variable row (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._live_watch_vars): + self._live_watch_vars.pop(index) + finally: + self._mutex.unlock() + + def get_live_watch_var(self, index: int) -> WatchVariable: + """Get live watch variable at index (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._live_watch_vars): + return self._live_watch_vars[index] + return WatchVariable() + finally: + self._mutex.unlock() + + def update_live_watch_var_field(self, index: int, field: str, value: Any): + """Update a specific field of a live watch variable (thread-safe).""" + self._mutex.lock() + try: + if 0 <= index < len(self._live_watch_vars): + setattr(self._live_watch_vars[index], field, value) + # Cache the x2cscope variable reference when name is set + if field == "name" and value and value != "None" and self._x2cscope: + sfr = self._live_watch_vars[index].sfr + var_ref = self._x2cscope.get_variable(value, sfr=sfr) + if var_ref is not None: + self._live_watch_vars[index].var_ref = var_ref + finally: + self._mutex.unlock() + + def get_active_live_watch_vars(self) -> List[Dict[str, Any]]: + """Get all live watch variables with live=True (thread-safe).""" + self._mutex.lock() + try: + return [ + {"index": i, "name": v.name, "live": v.live} + for i, v in enumerate(self._live_watch_vars) + if v.live and v.name and v.name != "None" + ] + finally: + self._mutex.unlock() + + def get_all_live_watch_vars(self) -> List[WatchVariable]: + """Get all live watch variables (thread-safe copy).""" + self._mutex.lock() + try: + return [ + WatchVariable( + name=v.name, + value=v.value, + scaling=v.scaling, + offset=v.offset, + unit=v.unit, + live=v.live, + plot_enabled=v.plot_enabled, + ) + for v in self._live_watch_vars + ] + finally: + self._mutex.unlock() + + def get_live_watch_var_count(self) -> int: + """Get count of live watch variables (thread-safe).""" + self._mutex.lock() + try: + return len(self._live_watch_vars) + finally: + self._mutex.unlock() + + def clear_live_watch_vars(self): + """Clear all live watch variables (thread-safe).""" + self._mutex.lock() + try: + self._live_watch_vars.clear() + finally: + self._mutex.unlock() + + # ============= Plot Data ============= + + def append_plot_data(self, data: tuple): + """Append data to plot buffer (thread-safe).""" + self._mutex.lock() + try: + self._plot_data.append(data) + finally: + self._mutex.unlock() + + def get_plot_data(self) -> List[tuple]: + """Get plot data (thread-safe copy).""" + self._mutex.lock() + try: + return list(self._plot_data) + finally: + self._mutex.unlock() + + def clear_plot_data(self): + """Clear plot data buffer (thread-safe).""" + self._mutex.lock() + try: + self._plot_data.clear() + finally: + self._mutex.unlock() + + # ============= Timing Configuration ============= + + @property + def watch_poll_interval_ms(self) -> int: + """Get the watch poll interval in milliseconds.""" + return self._watch_poll_interval_ms + + @watch_poll_interval_ms.setter + def watch_poll_interval_ms(self, value: int): + self._mutex.lock() + self._watch_poll_interval_ms = max(50, value) + self._mutex.unlock() diff --git a/pyx2cscope/gui/qt/tabs/__init__.py b/pyx2cscope/gui/qt/tabs/__init__.py new file mode 100644 index 00000000..786e0f1f --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/__init__.py @@ -0,0 +1,9 @@ +"""Tab widgets for the Qt GUI.""" + +from .base_tab import BaseTab +from .scope_view_tab import ScopeViewTab +from .scripting_tab import ScriptingTab +from .setup_tab import SetupTab +from .watch_view_tab import WatchViewTab + +__all__ = ["BaseTab", "ScopeViewTab", "ScriptingTab", "SetupTab", "WatchViewTab"] diff --git a/pyx2cscope/gui/qt/tabs/base_tab.py b/pyx2cscope/gui/qt/tabs/base_tab.py new file mode 100644 index 00000000..595b9ab9 --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/base_tab.py @@ -0,0 +1,111 @@ +"""Base tab class for the Qt GUI tabs.""" + +from typing import TYPE_CHECKING + +from PyQt5.QtCore import QRegExp +from PyQt5.QtGui import QRegExpValidator +from PyQt5.QtWidgets import QWidget + +if TYPE_CHECKING: + from pyx2cscope.gui.qt.models.app_state import AppState + + +class BaseTab(QWidget): + """Base class for all tab widgets. + + Provides common functionality and access to shared resources. + """ + + # Common colors for plots + PLOT_COLORS = ["b", "g", "r", "c", "m", "y", "k"] + + def __init__(self, app_state: "AppState", parent=None): + """Initialize the base tab. + + Args: + app_state: The centralized application state. + parent: Optional parent widget. + """ + super().__init__(parent) + self._app_state = app_state + self._setup_validators() + + def _setup_validators(self): + """Set up input validators.""" + decimal_regex = QRegExp(r"-?[0-9]+(\.[0-9]+)?") + self._decimal_validator = QRegExpValidator(decimal_regex) + + @property + def app_state(self) -> "AppState": + """Get the application state.""" + return self._app_state + + @property + def decimal_validator(self) -> QRegExpValidator: + """Get the decimal number validator.""" + return self._decimal_validator + + def on_connection_changed(self, connected: bool): + """Handle connection state changes. + + Override in subclasses to update UI based on connection state. + + Args: + connected: True if connected, False otherwise. + """ + pass + + def on_variable_list_updated(self, variables: list): + """Handle variable list updates. + + Override in subclasses to update UI when variables change. + + Args: + variables: List of available variable names. + """ + pass + + def calculate_scaled_value( + self, value: float, scaling: float, offset: float + ) -> float: + """Calculate a scaled value. + + Args: + value: The raw value. + scaling: The scaling factor. + offset: The offset to add. + + Returns: + The scaled value: (value * scaling) + offset + """ + return (value * scaling) + offset + + def safe_float(self, text: str, default: float = 0.0) -> float: + """Safely convert text to float. + + Args: + text: The text to convert. + default: Default value if conversion fails. + + Returns: + The converted float or default value. + """ + try: + return float(text) if text else default + except ValueError: + return default + + def safe_int(self, text: str, default: int = 0) -> int: + """Safely convert text to int. + + Args: + text: The text to convert. + default: Default value if conversion fails. + + Returns: + The converted int or default value. + """ + try: + return int(text) if text else default + except ValueError: + return default diff --git a/pyx2cscope/gui/qt/tabs/scope_view_tab.py b/pyx2cscope/gui/qt/tabs/scope_view_tab.py new file mode 100644 index 00000000..d19dcb6c --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/scope_view_tab.py @@ -0,0 +1,540 @@ +"""ScopeView tab (Tab2) - Scope capture and trigger configuration.""" + +import logging +from typing import TYPE_CHECKING, Dict, List, Optional + +import numpy as np +import pyqtgraph as pg +from PyQt5 import QtCore +from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot +from PyQt5.QtGui import QColor, QIcon, QPixmap +from PyQt5.QtWidgets import ( + QCheckBox, + QComboBox, + QDialog, + QGridLayout, + QGroupBox, + QLabel, + QLineEdit, + QPushButton, + QSizePolicy, + QVBoxLayout, +) + +from pyx2cscope.gui.qt.dialogs.variable_selection import VariableSelectionDialog +from pyx2cscope.gui.qt.tabs.base_tab import BaseTab +from pyx2cscope.x2cscope import TriggerConfig + +if TYPE_CHECKING: + from pyx2cscope.gui.qt.models.app_state import AppState + + +class ScopeViewTab(BaseTab): + """Tab for oscilloscope-style data capture and visualization. + + Features: + - 8 scope channels with trigger selection + - Configurable trigger mode, edge, level, and delay + - Single-shot and continuous capture modes + - Real-time plotting with pyqtgraph + """ + + # Signal emitted when scope sampling state changes: (is_sampling, is_single_shot) + scope_sampling_changed = pyqtSignal(bool, bool) + + MAX_CHANNELS = 8 + + def __init__(self, app_state: "AppState", parent=None): + """Initialize the ScopeView tab. + + Args: + app_state: The centralized application state. + parent: Optional parent widget. + """ + super().__init__(app_state, parent) + self._variable_list: List[str] = [] + self._trigger_variable: Optional[str] = None + self._sampling_active: bool = False + self._real_sampletime: float = 0.0 + + # Widget lists + self._var_line_edits: List[QLineEdit] = [] + self._trigger_checkboxes: List[QCheckBox] = [] + self._scaling_edits: List[QLineEdit] = [] + self._offset_edits: List[QLineEdit] = [] + self._color_combos: List[QComboBox] = [] + self._visible_checkboxes: List[QCheckBox] = [] + + # Available colors for channels (name -> RGB tuple) + self._colors = { + "Blue": (0, 0, 255), + "Green": (0, 255, 0), + "Red": (255, 0, 0), + "Cyan": (0, 255, 255), + "Magenta": (255, 0, 255), + "Yellow": (255, 255, 0), + "Orange": (255, 165, 0), + "Purple": (128, 0, 128), + "Black": (0, 0, 0), + "White": (255, 255, 255), + } + + self._setup_ui() + + def _setup_ui(self): + """Set up the user interface.""" + layout = QVBoxLayout() + self.setLayout(layout) + + # Plot widget (at the top) + self._plot_widget = pg.PlotWidget() + self._plot_widget.setBackground("w") + self._plot_widget.showGrid(x=True, y=True) + self._plot_widget.getViewBox().setMouseMode(pg.ViewBox.RectMode) + layout.addWidget(self._plot_widget, stretch=2) + + # Main grid for trigger config and variable selection (below plot) + main_grid = QGridLayout() + layout.addLayout(main_grid) + + # Trigger configuration group + trigger_group = self._create_trigger_group() + main_grid.addWidget(trigger_group, 0, 0) + + # Variable selection group + variable_group = self._create_variable_group() + main_grid.addWidget(variable_group, 0, 1) + + # Set column stretch + main_grid.setColumnStretch(0, 1) + main_grid.setColumnStretch(1, 3) + + def _create_trigger_group(self) -> QGroupBox: + """Create the trigger configuration group box.""" + group = QGroupBox("Trigger Configuration") + layout = QVBoxLayout() + group.setLayout(layout) + + grid = QGridLayout() + layout.addLayout(grid) + + # Single shot checkbox + self._single_shot_checkbox = QCheckBox("Single Shot") + grid.addWidget(self._single_shot_checkbox, 0, 0, 1, 2) + + # Sample time factor + grid.addWidget(QLabel("Sample Time Factor"), 1, 0) + self._sample_time_factor_edit = QLineEdit("1") + self._sample_time_factor_edit.setValidator(self.decimal_validator) + grid.addWidget(self._sample_time_factor_edit, 1, 1) + + # Scope sample time + grid.addWidget(QLabel("Scope Sample Time (us):"), 2, 0) + self._scope_sampletime_edit = QLineEdit("50") + self._scope_sampletime_edit.setValidator(self.decimal_validator) + grid.addWidget(self._scope_sampletime_edit, 2, 1) + + # Trigger mode + grid.addWidget(QLabel("Trigger Mode:"), 3, 0) + self._trigger_mode_combo = QComboBox() + self._trigger_mode_combo.addItems(["Auto", "Triggered"]) + grid.addWidget(self._trigger_mode_combo, 3, 1) + + # Trigger edge + grid.addWidget(QLabel("Trigger Edge:"), 4, 0) + self._trigger_edge_combo = QComboBox() + self._trigger_edge_combo.addItems(["Rising", "Falling"]) + grid.addWidget(self._trigger_edge_combo, 4, 1) + + # Trigger level + grid.addWidget(QLabel("Trigger Level:"), 5, 0) + self._trigger_level_edit = QLineEdit("0") + self._trigger_level_edit.setValidator(self.decimal_validator) + grid.addWidget(self._trigger_level_edit, 5, 1) + + # Trigger delay (combo box with -50% to +50% in 10% steps) + grid.addWidget(QLabel("Trigger Delay (%):"), 6, 0) + self._trigger_delay_combo = QComboBox() + self._trigger_delay_combo.addItems(["-50", "-40", "-30", "-20", "-10", "0", "10", "20", "30", "40", "50"]) + self._trigger_delay_combo.setCurrentText("0") + grid.addWidget(self._trigger_delay_combo, 6, 1) + + # Sample button + self._sample_button = QPushButton("Sample") + self._sample_button.setFixedSize(100, 30) + self._sample_button.clicked.connect(self._on_sample_clicked) + grid.addWidget(self._sample_button, 7, 0, 1, 2) + + return group + + def _create_variable_group(self) -> QGroupBox: # noqa: PLR0915 + """Create the variable selection group box.""" + group = QGroupBox("Variable Selection") + layout = QVBoxLayout() + group.setLayout(layout) + + grid = QGridLayout() + layout.addLayout(grid) + + # Headers + grid.addWidget(QLabel("Trigger"), 0, 0) + grid.addWidget(QLabel("Search Variable"), 0, 1) + grid.addWidget(QLabel("Gain"), 0, 2) + grid.addWidget(QLabel("Offset"), 0, 3) + grid.addWidget(QLabel("Color"), 0, 4) + grid.addWidget(QLabel("Visible"), 0, 5) + + # Channel rows + for i in range(self.MAX_CHANNELS): + row = i + 1 + + # Trigger checkbox + trigger_cb = QCheckBox() + trigger_cb.setMinimumHeight(20) + trigger_cb.stateChanged.connect(lambda state, idx=i: self._on_trigger_changed(idx, state)) + self._trigger_checkboxes.append(trigger_cb) + grid.addWidget(trigger_cb, row, 0) + + # Variable line edit + line_edit = QLineEdit() + line_edit.setReadOnly(True) + line_edit.setPlaceholderText("Search Variable") + line_edit.setMinimumHeight(20) + line_edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) + line_edit.installEventFilter(self) + self._var_line_edits.append(line_edit) + grid.addWidget(line_edit, row, 1) + + # Scaling edit (Gain) + scaling_edit = QLineEdit("1") + scaling_edit.setFixedSize(50, 20) + scaling_edit.setValidator(self.decimal_validator) + scaling_edit.editingFinished.connect(self._update_plot) + self._scaling_edits.append(scaling_edit) + grid.addWidget(scaling_edit, row, 2) + + # Offset edit + offset_edit = QLineEdit("0") + offset_edit.setFixedSize(50, 20) + offset_edit.setValidator(self.decimal_validator) + offset_edit.editingFinished.connect(self._update_plot) + self._offset_edits.append(offset_edit) + grid.addWidget(offset_edit, row, 3) + + # Color combo with colored squares + color_combo = QComboBox() + self._populate_color_combo(color_combo) + color_combo.setCurrentIndex(i % len(self._colors)) + color_combo.setFixedSize(50, 20) + color_combo.currentIndexChanged.connect(lambda idx: self._update_plot()) + self._color_combos.append(color_combo) + grid.addWidget(color_combo, row, 4) + + # Visible checkbox + visible_cb = QCheckBox() + visible_cb.setChecked(True) + visible_cb.setMinimumHeight(20) + visible_cb.stateChanged.connect(lambda state: self._update_plot()) + self._visible_checkboxes.append(visible_cb) + grid.addWidget(visible_cb, row, 5) + + return group + + def _populate_color_combo(self, combo: QComboBox): + """Populate a combobox with colored square icons.""" + for name, rgb in self._colors.items(): + pixmap = QPixmap(16, 16) + pixmap.fill(QColor(*rgb)) + combo.addItem(QIcon(pixmap), "", name) # Store color name as item data + + def _get_color_from_combo(self, combo: QComboBox) -> tuple: + """Get the RGB color tuple from a color combo box.""" + color_name = combo.currentData() + if color_name and color_name in self._colors: + return self._colors[color_name] + # Fallback to index-based lookup + idx = combo.currentIndex() + color_names = list(self._colors.keys()) + if 0 <= idx < len(color_names): + return self._colors[color_names[idx]] + return (0, 0, 255) # Default to blue + + def on_connection_changed(self, connected: bool): + """Handle connection state changes.""" + self._sample_button.setEnabled(connected) + for line_edit in self._var_line_edits: + line_edit.setEnabled(connected) + + def on_variable_list_updated(self, variables: list): + """Handle variable list updates.""" + self._variable_list = variables + + def eventFilter(self, source, event): # noqa: N802 + """Event filter to handle line edit click events for variable selection.""" + if event.type() == QtCore.QEvent.MouseButtonPress: + if isinstance(source, QLineEdit) and source in self._var_line_edits: + index = self._var_line_edits.index(source) + self._on_variable_click(index) + return True # Consume the event after handling + return super().eventFilter(source, event) + + def _on_variable_click(self, index: int): + """Handle click on variable field to open selection dialog.""" + if not self._variable_list: + return + + sfr_list = self._app_state.get_sfr_list() + dialog = VariableSelectionDialog(self._variable_list, self, sfr_variables=sfr_list) + if dialog.exec_() == QDialog.Accepted and dialog.selected_variable: + self._var_line_edits[index].setText(dialog.selected_variable) + # Store sfr flag before updating name so sampling uses the right namespace + self._app_state.update_scope_channel_field(index, "sfr", dialog.sfr_selected) + self._app_state.update_scope_channel_field(index, "name", dialog.selected_variable) + + def _on_trigger_changed(self, index: int, state: int): + """Handle trigger checkbox change - only one can be selected.""" + if state == Qt.Checked: + # Uncheck all other trigger checkboxes + for i, cb in enumerate(self._trigger_checkboxes): + if i != index: + cb.setChecked(False) + self._trigger_variable = self._var_line_edits[index].text() + self._app_state.update_scope_channel_field(index, "trigger", True) + logging.debug(f"Trigger variable set to: {self._trigger_variable}") + else: + self._trigger_variable = None + self._app_state.update_scope_channel_field(index, "trigger", False) + + def _on_sample_clicked(self): + """Handle sample button click.""" + if not self._app_state.is_connected(): + return + + if self._sampling_active: + self._stop_sampling() + else: + self._start_sampling() + + def _start_sampling(self): + """Start scope sampling.""" + try: + x2cscope = self._app_state.x2cscope + if not x2cscope: + return + + # Clear existing channels + x2cscope.clear_all_scope_channel() + + # Add configured channels + for i, line_edit in enumerate(self._var_line_edits): + var_name = line_edit.text() + if var_name and var_name != "None": + sfr = self._app_state.get_scope_channel(i).sfr + variable = x2cscope.get_variable(var_name, sfr=sfr) + if variable is not None: + x2cscope.add_scope_channel(variable) + logging.debug(f"Added scope channel: {var_name}") + + # Set sample time + sample_time_factor = self.safe_int(self._sample_time_factor_edit.text(), 1) + x2cscope.set_sample_time(sample_time_factor) + + # Get real sample time + scope_sample_time_us = self.safe_int(self._scope_sampletime_edit.text(), 50) + self._real_sampletime = x2cscope.get_scope_sample_time(scope_sample_time_us) + + # Configure trigger + self._configure_trigger() + + # Start sampling + self._sampling_active = True + self._sample_button.setText("Stop") + x2cscope.request_scope_data() + + # Emit signal to notify DataPoller + self.scope_sampling_changed.emit(True, self._single_shot_checkbox.isChecked()) + + logging.info("Started scope sampling") + + except Exception as e: + error_msg = f"Error starting sampling: {e}" + logging.error(error_msg) + + def _stop_sampling(self): + """Stop scope sampling.""" + self._sampling_active = False + self._sample_button.setText("Sample") + + x2cscope = self._app_state.x2cscope + if x2cscope: + x2cscope.clear_all_scope_channel() + + # Emit signal to notify DataPoller + self.scope_sampling_changed.emit(False, False) + + logging.info("Stopped scope sampling") + + def _configure_trigger(self): + """Configure the scope trigger.""" + try: + x2cscope = self._app_state.x2cscope + if not x2cscope: + return + + trigger_mode = self._trigger_mode_combo.currentText() + + if trigger_mode == "Auto": + x2cscope.reset_scope_trigger() + return + + if not self._trigger_variable: + x2cscope.reset_scope_trigger() + return + + # Find the sfr flag for the trigger channel + trigger_sfr = next( + ( + self._app_state.get_scope_channel(i).sfr + for i, le in enumerate(self._var_line_edits) + if le.text() == self._trigger_variable + and i < len(self._trigger_checkboxes) + and self._trigger_checkboxes[i].isChecked() + ), + False, + ) + variable = x2cscope.get_variable(self._trigger_variable, sfr=trigger_sfr) + if variable is None: + logging.warning(f"Trigger variable not found: {self._trigger_variable}") + return + + trigger_level = self.safe_float(self._trigger_level_edit.text()) + trigger_delay = self.safe_int(self._trigger_delay_combo.currentText()) + + # Rising = 0, Falling = 1 (per TriggerConfig spec) + trigger_edge = 1 if self._trigger_edge_combo.currentText() == "Rising" else 0 + trigger_mode_val = 1 # Triggered mode + + trigger_config = TriggerConfig( + variable=variable, + trigger_level=trigger_level, + trigger_mode=trigger_mode_val, + trigger_delay=trigger_delay, + trigger_edge=trigger_edge, + ) + x2cscope.set_scope_trigger(trigger_config) + logging.info("Trigger configured") + + except Exception as e: + logging.error(f"Error configuring trigger: {e}") + + @pyqtSlot(dict) + def on_scope_data_ready(self, data: Dict[str, List[float]]): + """Handle scope data ready signal from data poller. + + Args: + data: Dictionary of channel name to data values. + """ + if not self._sampling_active: + return + + self._plot_widget.clear() + + for i, (channel, values) in enumerate(data.items()): + if i >= self.MAX_CHANNELS: + break + + if self._visible_checkboxes[i].isChecked(): + scale_factor = self.safe_float(self._scaling_edits[i].text(), 1.0) + offset = self.safe_float(self._offset_edits[i].text(), 0.0) + time_values = np.linspace(0, self._real_sampletime, len(values)) + data_scaled = (np.array(values, dtype=float) * scale_factor) + offset + + # Get color from combo box (RGB tuple) + color = self._get_color_from_combo(self._color_combos[i]) + + self._plot_widget.plot( + time_values, + data_scaled, + pen=pg.mkPen(color=color, width=2), + name=f"{channel}", + ) + + self._plot_widget.setLabel("left", "Value") + self._plot_widget.setLabel("bottom", "Time", units="ms") + self._plot_widget.showGrid(x=True, y=True) + + # Handle single-shot mode - stop sampling after receiving data + if self._single_shot_checkbox.isChecked(): + self._stop_sampling() + # Note: In continuous mode, DataPoller handles requesting next data + + def _update_plot(self): + """Update the plot (called when scale or visibility changes).""" + # The plot will be updated on next data ready signal + pass + + @property + def is_sampling(self) -> bool: + """Check if currently sampling.""" + return self._sampling_active + + @property + def is_single_shot(self) -> bool: + """Check if single-shot mode is enabled.""" + return self._single_shot_checkbox.isChecked() + + def get_config(self) -> dict: + """Get the current tab configuration.""" + return { + "variables": [le.text() for le in self._var_line_edits], + "trigger": [cb.isChecked() for cb in self._trigger_checkboxes], + "scale": [sc.text() for sc in self._scaling_edits], + "offset": [off.text() for off in self._offset_edits], + "color": [cb.currentData() or list(self._colors.keys())[cb.currentIndex()] for cb in self._color_combos], + "show": [cb.isChecked() for cb in self._visible_checkboxes], + "trigger_variable": self._trigger_variable, + "trigger_level": self._trigger_level_edit.text(), + "trigger_delay": self._trigger_delay_combo.currentText(), + "trigger_edge": self._trigger_edge_combo.currentText(), + "trigger_mode": self._trigger_mode_combo.currentText(), + "sample_time_factor": self._sample_time_factor_edit.text(), + "single_shot": self._single_shot_checkbox.isChecked(), + } + + def load_config(self, config: dict): + """Load configuration into the tab.""" + variables = config.get("variables", []) + triggers = config.get("trigger", []) + scales = config.get("scale", []) + offsets = config.get("offset", []) + colors = config.get("color", []) + shows = config.get("show", []) + + for i, (le, var) in enumerate(zip(self._var_line_edits, variables)): + le.setText(var) + # Update app state with variable name + self._app_state.update_scope_channel_field(i, "name", var) + for i, (cb, trigger) in enumerate(zip(self._trigger_checkboxes, triggers)): + cb.setChecked(trigger) + self._app_state.update_scope_channel_field(i, "trigger", trigger) + for i, (sc, scale) in enumerate(zip(self._scaling_edits, scales)): + sc.setText(scale) + for off, offset in zip(self._offset_edits, offsets): + off.setText(offset) + for cb, color_name in zip(self._color_combos, colors): + # Find the index of the color by name in item data + for idx in range(cb.count()): + if cb.itemData(idx) == color_name: + cb.setCurrentIndex(idx) + break + for i, (cb, show) in enumerate(zip(self._visible_checkboxes, shows)): + cb.setChecked(show) + self._app_state.update_scope_channel_field(i, "visible", show) + + self._trigger_variable = config.get("trigger_variable", "") + self._trigger_level_edit.setText(config.get("trigger_level", "0")) + self._trigger_delay_combo.setCurrentText(config.get("trigger_delay", "0")) + self._trigger_edge_combo.setCurrentText(config.get("trigger_edge", "Rising")) + self._trigger_mode_combo.setCurrentText(config.get("trigger_mode", "Auto")) + self._sample_time_factor_edit.setText(config.get("sample_time_factor", "1")) + self._single_shot_checkbox.setChecked(config.get("single_shot", False)) diff --git a/pyx2cscope/gui/qt/tabs/scripting_tab.py b/pyx2cscope/gui/qt/tabs/scripting_tab.py new file mode 100644 index 00000000..d6fdc0c2 --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/scripting_tab.py @@ -0,0 +1,586 @@ +"""Scripting tab - Execute Python scripts with access to x2cscope.""" + +import io +import os +import subprocess +import sys +import traceback +from contextlib import redirect_stderr, redirect_stdout +from datetime import datetime +from typing import TYPE_CHECKING + +from PyQt5.QtCore import QSettings, Qt, QThread, pyqtSignal +from PyQt5.QtWidgets import ( + QCheckBox, + QDialog, + QDialogButtonBox, + QFileDialog, + QGroupBox, + QHBoxLayout, + QLabel, + QLineEdit, + QPlainTextEdit, + QPushButton, + QTabWidget, + QTextBrowser, + QVBoxLayout, + QWidget, +) + +from pyx2cscope.gui.resources import get_resource_path + +if TYPE_CHECKING: + from pyx2cscope.gui.qt.models.app_state import AppState + + +class ScriptHelpDialog(QDialog): + """Dialog showing help for writing scripts.""" + + def __init__(self, parent=None): + """Initialize the script help dialog.""" + super().__init__(parent) + self.setWindowTitle("Script Help") + self.setMinimumSize(700, 600) + self._setup_ui() + + def _setup_ui(self): + layout = QVBoxLayout(self) + + help_browser = QTextBrowser() + help_browser.setOpenExternalLinks(True) + help_browser.setStyleSheet( + "QTextBrowser { font-family: Segoe UI, Arial, sans-serif; font-size: 10pt; }" + ) + help_browser.setMarkdown(self._load_help_content()) + layout.addWidget(help_browser) + + button_box = QDialogButtonBox(QDialogButtonBox.Ok) + button_box.accepted.connect(self.accept) + layout.addWidget(button_box) + + def _load_help_content(self) -> str: + """Load help content from external markdown file.""" + try: + help_path = get_resource_path("script_help.md") + with open(help_path, "r", encoding="utf-8") as f: + return f.read() + except Exception as e: + return f"# Error\n\nCould not load help file: {e}\n\nPlease check that `script_help.md` exists in the resources folder." + + +class ScriptWorker(QThread): + """Worker thread for executing Python scripts.""" + + output_ready = pyqtSignal(str) + finished_with_code = pyqtSignal(int) + + def __init__(self, script_path: str, x2cscope, parent=None): + """Initialize the script worker. + + Args: + script_path: Path to the Python script to execute. + x2cscope: The x2cscope instance to inject into script namespace. + parent: Optional parent QObject. + """ + super().__init__(parent) + self._script_path = script_path + self._x2cscope = x2cscope + self._stop_requested = False + + def is_stop_requested(self) -> bool: + """Check if stop has been requested. Scripts should call this in loops.""" + return self._stop_requested + + def run(self): + """Execute the script in this thread.""" + exit_code = 0 + + # Create a custom stdout/stderr that emits signals + class OutputCapture(io.StringIO): + def __init__(self, signal): + super().__init__() + self._signal = signal + + def write(self, text): + if text: + self._signal.emit(text) + return len(text) if text else 0 + + def flush(self): + pass + + stdout_capture = OutputCapture(self.output_ready) + stderr_capture = OutputCapture(self.output_ready) + + try: + with open(self._script_path, "r", encoding="utf-8") as f: + script_code = f.read() + + # Create namespace with x2cscope and stop_requested function + namespace = { + "__name__": "__main__", + "__file__": self._script_path, + "x2cscope": self._x2cscope, + "stop_requested": self.is_stop_requested, + } + + # Execute with captured output + with redirect_stdout(stdout_capture), redirect_stderr(stderr_capture): + exec(compile(script_code, self._script_path, "exec"), namespace) + + except SystemExit as e: + # Handle sys.exit() calls in scripts + exit_code = e.code if isinstance(e.code, int) else 1 + except StopIteration: + # Script was stopped via stop_requested + exit_code = 0 + except Exception as e: + self.output_ready.emit(f"\nScript error: {e}\n") + self.output_ready.emit(traceback.format_exc()) + exit_code = 1 + + self.finished_with_code.emit(exit_code) + + def request_stop(self): + """Request the script to stop. Scripts should check stop_requested() in loops.""" + self._stop_requested = True + + +class ScriptingTab(QWidget): + """Tab for executing Python scripts with x2cscope access. + + Features: + - Select and execute Python scripts + - View script output in real-time (separate tab) + - Log messages with timestamps (separate tab) + - Option to log output to file with custom location + - Edit scripts with IDLE + - Scripts can access the x2cscope instance from the main app + """ + + # Signals + script_started = pyqtSignal() + script_finished = pyqtSignal(int) # exit code + + def __init__(self, app_state: "AppState", parent=None): + """Initialize the Scripting tab. + + Args: + app_state: The centralized application state. + parent: Optional parent widget. + """ + super().__init__(parent) + self._app_state = app_state + self._script_path = "" + self._settings = QSettings("Microchip", "pyX2Cscope") + self._worker = None + self._log_file = None + self._log_file_path = "" + + self._setup_ui() + + def _setup_ui(self): # noqa: PLR0915 + """Set up the user interface.""" + main_layout = QVBoxLayout() + main_layout.setContentsMargins(10, 10, 10, 10) + self.setLayout(main_layout) + + # === Script Selection Group === + script_group = QGroupBox("Script Selection") + script_layout = QHBoxLayout() + script_layout.setSpacing(8) + script_layout.setContentsMargins(10, 15, 10, 10) + script_group.setLayout(script_layout) + + # Script path display + self._script_path_edit = QLineEdit() + self._script_path_edit.setReadOnly(True) + self._script_path_edit.setPlaceholderText("No script selected") + script_layout.addWidget(self._script_path_edit, 1) + + # Browse button + self._browse_btn = QPushButton("Browse...") + self._browse_btn.setFixedWidth(80) + self._browse_btn.clicked.connect(self._on_browse_clicked) + script_layout.addWidget(self._browse_btn) + + # Edit with IDLE button + self._edit_btn = QPushButton("Edit (IDLE)") + self._edit_btn.setFixedWidth(90) + self._edit_btn.clicked.connect(self._on_edit_clicked) + self._edit_btn.setEnabled(False) + script_layout.addWidget(self._edit_btn) + + # Help button + self._help_btn = QPushButton("Help") + self._help_btn.setFixedWidth(60) + self._help_btn.clicked.connect(self._on_help_clicked) + script_layout.addWidget(self._help_btn) + + main_layout.addWidget(script_group) + + # === Execution Controls Group === + controls_group = QGroupBox("Execution Controls") + controls_layout = QVBoxLayout() + controls_layout.setSpacing(8) + controls_layout.setContentsMargins(10, 15, 10, 10) + controls_group.setLayout(controls_layout) + + # First row: Execute, Stop, Status + row1_layout = QHBoxLayout() + + # Execute button + self._execute_btn = QPushButton("Execute") + self._execute_btn.setFixedSize(100, 30) + self._execute_btn.clicked.connect(self._on_execute_clicked) + self._execute_btn.setEnabled(False) + row1_layout.addWidget(self._execute_btn) + + # Stop button + self._stop_btn = QPushButton("Stop") + self._stop_btn.setFixedSize(100, 30) + self._stop_btn.clicked.connect(self._on_stop_clicked) + self._stop_btn.setEnabled(False) + self._stop_btn.setToolTip("Request script to stop (may not work for blocking operations)") + row1_layout.addWidget(self._stop_btn) + + # Status label + row1_layout.addStretch() + self._status_label = QLabel("Ready") + self._status_label.setStyleSheet("color: #666;") + row1_layout.addWidget(self._status_label) + + controls_layout.addLayout(row1_layout) + + # Second row: Log to file checkbox and path + row2_layout = QHBoxLayout() + + # Log to file checkbox + self._log_checkbox = QCheckBox("Log output to file:") + self._log_checkbox.setChecked(False) + self._log_checkbox.stateChanged.connect(self._on_log_checkbox_changed) + row2_layout.addWidget(self._log_checkbox) + + # Log file path display + self._log_path_edit = QLineEdit() + self._log_path_edit.setReadOnly(True) + self._log_path_edit.setPlaceholderText("Select log file location...") + self._log_path_edit.setEnabled(False) + row2_layout.addWidget(self._log_path_edit, 1) + + # Browse log location button + self._log_browse_btn = QPushButton("Browse...") + self._log_browse_btn.setFixedWidth(80) + self._log_browse_btn.clicked.connect(self._on_log_browse_clicked) + self._log_browse_btn.setEnabled(False) + row2_layout.addWidget(self._log_browse_btn) + + controls_layout.addLayout(row2_layout) + + main_layout.addWidget(controls_group) + + # === Output Tabs === + self._output_tabs = QTabWidget() + + # Script Output tab + script_output_widget = QWidget() + script_output_layout = QVBoxLayout(script_output_widget) + script_output_layout.setContentsMargins(5, 5, 5, 5) + + self._script_output_text = QPlainTextEdit() + self._script_output_text.setReadOnly(True) + self._script_output_text.setStyleSheet( + "QPlainTextEdit { font-family: Consolas, monospace; font-size: 10pt; }" + ) + script_output_layout.addWidget(self._script_output_text) + + # Clear button for script output + script_clear_layout = QHBoxLayout() + script_clear_layout.addStretch() + script_clear_btn = QPushButton("Clear") + script_clear_btn.setFixedWidth(80) + script_clear_btn.clicked.connect(self._script_output_text.clear) + script_clear_layout.addWidget(script_clear_btn) + script_output_layout.addLayout(script_clear_layout) + + self._output_tabs.addTab(script_output_widget, "Script Output") + + # Log Output tab + log_output_widget = QWidget() + log_output_layout = QVBoxLayout(log_output_widget) + log_output_layout.setContentsMargins(5, 5, 5, 5) + + self._log_output_text = QPlainTextEdit() + self._log_output_text.setReadOnly(True) + self._log_output_text.setStyleSheet( + "QPlainTextEdit { font-family: Consolas, monospace; font-size: 10pt; " + "color: #555; }" + ) + log_output_layout.addWidget(self._log_output_text) + + # Clear button for log output + log_clear_layout = QHBoxLayout() + log_clear_layout.addStretch() + log_clear_btn = QPushButton("Clear") + log_clear_btn.setFixedWidth(80) + log_clear_btn.clicked.connect(self._log_output_text.clear) + log_clear_layout.addWidget(log_clear_btn) + log_output_layout.addLayout(log_clear_layout) + + self._output_tabs.addTab(log_output_widget, "Log") + + main_layout.addWidget(self._output_tabs, 1) # Stretch factor 1 + + # === Info Label === + info_label = QLabel( + "Scripts have access to 'x2cscope' variable when connected. " + "Click Help for examples and documentation." + ) + info_label.setStyleSheet("color: #666; font-style: italic; padding: 5px;") + info_label.setWordWrap(True) + main_layout.addWidget(info_label) + + def _on_log_checkbox_changed(self, state): + """Handle log checkbox state change.""" + enabled = state == Qt.Checked + self._log_path_edit.setEnabled(enabled) + self._log_browse_btn.setEnabled(enabled) + + if enabled and not self._log_file_path: + # Suggest a default path based on script location + if self._script_path: + script_dir = os.path.dirname(self._script_path) + script_name = os.path.splitext(os.path.basename(self._script_path))[0] + self._log_file_path = os.path.join(script_dir, f"{script_name}_log.txt") + self._log_path_edit.setText(self._log_file_path) + + def _on_log_browse_clicked(self): + """Handle log file browse button click.""" + # Get initial directory + if self._log_file_path: + initial_dir = os.path.dirname(self._log_file_path) + elif self._script_path: + initial_dir = os.path.dirname(self._script_path) + else: + initial_dir = self._settings.value("log_file_dir", "", type=str) + + # Generate default filename with timestamp + if self._script_path: + script_name = os.path.splitext(os.path.basename(self._script_path))[0] + default_name = f"{script_name}_log.txt" + else: + default_name = "script_log.txt" + + file_path, _ = QFileDialog.getSaveFileName( + self, + "Select Log File Location", + os.path.join(initial_dir, default_name), + "Text Files (*.txt);;Log Files (*.log);;All Files (*.*)", + ) + if file_path: + self._log_file_path = file_path + self._log_path_edit.setText(file_path) + self._settings.setValue("log_file_dir", os.path.dirname(file_path)) + + def _on_help_clicked(self): + """Show help dialog.""" + dialog = ScriptHelpDialog(self) + dialog.exec_() + + def _on_browse_clicked(self): + """Handle browse button click.""" + # Get last directory from settings + last_dir = self._settings.value("script_file_dir", "", type=str) + + file_path, _ = QFileDialog.getOpenFileName( + self, + "Select Python Script", + last_dir, + "Python Files (*.py);;All Files (*.*)", + ) + if file_path: + self._script_path = file_path + self._script_path_edit.setText(file_path) + self._settings.setValue("script_file_dir", os.path.dirname(file_path)) + self._edit_btn.setEnabled(True) + self._execute_btn.setEnabled(True) + self._log_message(f"Selected script: {file_path}") + + # Update suggested log path if logging is enabled + if self._log_checkbox.isChecked(): + script_dir = os.path.dirname(file_path) + script_name = os.path.splitext(os.path.basename(file_path))[0] + self._log_file_path = os.path.join(script_dir, f"{script_name}_log.txt") + self._log_path_edit.setText(self._log_file_path) + + def _on_edit_clicked(self): + """Open the script in IDLE.""" + if not self._script_path: + return + + try: + # Try to open with IDLE + if sys.platform == "win32": + # On Windows, use pythonw to avoid console window + subprocess.Popen( + [sys.executable, "-m", "idlelib.idle", self._script_path], + creationflags=subprocess.CREATE_NO_WINDOW, + ) + else: + subprocess.Popen([sys.executable, "-m", "idlelib.idle", self._script_path]) + self._log_message(f"Opened {os.path.basename(self._script_path)} in IDLE") + except Exception as e: + self._log_message(f"Error opening IDLE: {e}") + + def _on_execute_clicked(self): + """Execute the selected script.""" + if not self._script_path: + return + + if not os.path.exists(self._script_path): + self._log_message(f"Error: Script file not found: {self._script_path}") + return + + if self._worker is not None and self._worker.isRunning(): + self._log_message("A script is already running.") + return + + # Clear script output only + self._script_output_text.clear() + + # Setup logging if enabled + if self._log_checkbox.isChecked(): + self._setup_log_file() + + # Update UI state + self._execute_btn.setEnabled(False) + self._stop_btn.setEnabled(True) + self._status_label.setText("Running...") + self._status_label.setStyleSheet("color: #0078d4;") + + # Log messages go to Log tab + self._log_message(f"Script started: {os.path.basename(self._script_path)}") + + # Check if x2cscope is available + x2cscope = self._app_state.x2cscope + if x2cscope: + self._log_message("x2cscope instance available") + else: + self._log_message("x2cscope not connected (variable will be None)") + + # Create and start worker thread + self._worker = ScriptWorker(self._script_path, x2cscope, self) + self._worker.output_ready.connect(self._on_script_output) + self._worker.finished_with_code.connect(self._on_script_finished) + self._worker.start() + + self.script_started.emit() + + def _on_script_output(self, text: str): + """Handle output from the script worker - goes to Script Output tab.""" + self._append_script_output(text) + + def _on_script_finished(self, exit_code: int): + """Handle script completion.""" + self._log_message(f"Script finished with exit code {exit_code}") + + # Close log file if open + if self._log_file: + self._log_file.close() + self._log_file = None + + # Update UI state + self._execute_btn.setEnabled(True) + self._stop_btn.setEnabled(False) + + if exit_code == 0: + self._status_label.setText("Completed") + self._status_label.setStyleSheet("color: green;") + else: + self._status_label.setText(f"Finished (code {exit_code})") + self._status_label.setStyleSheet("color: orange;") + + self._worker = None + self.script_finished.emit(exit_code) + + def _on_stop_clicked(self): + """Stop the running script.""" + if self._worker and self._worker.isRunning(): + self._worker.request_stop() + self._log_message("Stop requested (may not work for blocking operations)") + self._status_label.setText("Stop requested...") + self._status_label.setStyleSheet("color: orange;") + + def _log_message(self, message: str): + """Add a timestamped message to the Log tab.""" + timestamp = datetime.now().strftime("%H:%M:%S") + formatted = f"[{timestamp}] {message}" + + cursor = self._log_output_text.textCursor() + cursor.movePosition(cursor.End) + if not self._log_output_text.toPlainText().endswith("\n") and self._log_output_text.toPlainText(): + cursor.insertText("\n") + cursor.insertText(formatted) + self._log_output_text.setTextCursor(cursor) + self._log_output_text.ensureCursorVisible() + + # Also write to log file if enabled + if self._log_file: + try: + self._log_file.write(f"{formatted}\n") + self._log_file.flush() + except Exception: + pass + + def _append_script_output(self, text: str): + """Append text to the Script Output tab.""" + cursor = self._script_output_text.textCursor() + cursor.movePosition(cursor.End) + cursor.insertText(text) + self._script_output_text.setTextCursor(cursor) + self._script_output_text.ensureCursorVisible() + + # Write to log file if enabled + if self._log_file: + try: + self._log_file.write(text) + self._log_file.flush() + except Exception: + pass + + def _setup_log_file(self): + """Setup log file for script output.""" + if not self._log_file_path: + self._log_message("Warning: No log file path specified") + return + + try: + # Create directory if it doesn't exist + log_dir = os.path.dirname(self._log_file_path) + if log_dir and not os.path.exists(log_dir): + os.makedirs(log_dir) + + self._log_file = open(self._log_file_path, "a", encoding="utf-8") + + # Write header + timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") + self._log_file.write(f"\n{'='*60}\n") + self._log_file.write(f"Script execution started: {timestamp}\n") + self._log_file.write(f"Script: {self._script_path}\n") + self._log_file.write(f"{'='*60}\n\n") + self._log_file.flush() + + self._log_message(f"Logging to: {self._log_file_path}") + except Exception as e: + self._log_message(f"Warning: Could not create log file: {e}") + self._log_file = None + + def on_connection_changed(self, connected: bool): + """Handle connection state change.""" + # Update info about x2cscope availability + if connected: + self._status_label.setText("Ready (x2cscope available)") + self._log_message("Connection established - x2cscope now available") + else: + self._status_label.setText("Ready (x2cscope not connected)") + self._log_message("Disconnected - x2cscope not available") diff --git a/pyx2cscope/gui/qt/tabs/setup_tab.py b/pyx2cscope/gui/qt/tabs/setup_tab.py new file mode 100644 index 00000000..0ffad4d3 --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/setup_tab.py @@ -0,0 +1,544 @@ +"""Setup tab - Connection and device configuration.""" + +import os +from typing import TYPE_CHECKING + +from PyQt5.QtCore import QRegExp, QSettings, Qt, pyqtSignal +from PyQt5.QtGui import QIcon, QIntValidator, QRegExpValidator +from PyQt5.QtWidgets import ( + QComboBox, + QFileDialog, + QGridLayout, + QGroupBox, + QHBoxLayout, + QLabel, + QLineEdit, + QPushButton, + QSizePolicy, + QVBoxLayout, + QWidget, +) + +from pyx2cscope.gui import img as img_src + +if TYPE_CHECKING: + from pyx2cscope.gui.qt.models.app_state import AppState + + +class SetupTab(QWidget): + """Tab for connection and device setup. + + Features: + - Interface selection (UART, TCP/IP, CAN) + - UART settings (Port, Baud Rate) + - TCP/IP settings (IP Address, Port) + - CAN settings (Bus Type, Channel, Baudrate, Mode, Tx-ID, Rx-ID) + - ELF file selection + - Device info display + """ + + # Constants + MAX_FILENAME_DISPLAY_LENGTH = 25 + + # Signals + connect_requested = pyqtSignal() + elf_file_selected = pyqtSignal(str) + + def __init__(self, app_state: "AppState", parent=None): + """Initialize the Setup tab. + + Args: + app_state: The centralized application state. + parent: Optional parent widget. + """ + super().__init__(parent) + self._app_state = app_state + self._elf_file_path = "" + self._settings = QSettings("Microchip", "pyX2Cscope") + + # Device info labels + self._device_info_labels = {} + + self._setup_ui() + self._restore_connection_settings() + + def _setup_ui(self): # noqa: PLR0915 + """Set up the user interface.""" + main_layout = QHBoxLayout() + main_layout.setContentsMargins(10, 10, 10, 10) + main_layout.setAlignment(Qt.AlignLeft | Qt.AlignTop) + self.setLayout(main_layout) + + # Left side: Connection settings + left_layout = QVBoxLayout() + left_layout.setAlignment(Qt.AlignTop) + + # === Connection Settings Group (ELF file + Interface selection) === + connection_group = QGroupBox("Connection Settings") + connection_layout = QGridLayout() + connection_layout.setSpacing(8) + connection_layout.setContentsMargins(10, 15, 10, 10) + connection_group.setLayout(connection_layout) + connection_group.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) + + row = 0 + + # ELF file selection + connection_layout.addWidget(QLabel("ELF File:"), row, 0, Qt.AlignRight) + self._elf_button = QPushButton("Select ELF file") + self._elf_button.setFixedWidth(200) + self._elf_button.clicked.connect(self._on_select_elf) + connection_layout.addWidget(self._elf_button, row, 1, 1, 2) + row += 1 + + # Interface selection + connection_layout.addWidget(QLabel("Interface:"), row, 0, Qt.AlignRight) + self._interface_combo = QComboBox() + self._interface_combo.addItems(["UART", "TCP/IP", "CAN"]) + self._interface_combo.setFixedWidth(120) + self._interface_combo.currentTextChanged.connect(self._on_interface_changed) + connection_layout.addWidget(self._interface_combo, row, 1) + row += 1 + + # Connect button and loading indicator row + connect_layout = QHBoxLayout() + self._connect_btn = QPushButton("Connect") + self._connect_btn.setFixedSize(100, 30) + self._connect_btn.clicked.connect(self._on_connect_clicked) + connect_layout.addWidget(self._connect_btn) + + # Loading indicator (simple text label) + self._loading_label = QLabel("Loading...") + self._loading_label.setStyleSheet("color: #666; font-style: italic;") + self._loading_label.hide() + connect_layout.addWidget(self._loading_label) + connect_layout.addStretch() + + connection_layout.addLayout(connect_layout, row, 1, 1, 2) + + self._connection_group = connection_group + left_layout.addWidget(connection_group) + + # === UART Settings Group === + self._uart_group = QGroupBox("UART Settings") + uart_layout = QGridLayout() + uart_layout.setSpacing(8) + uart_layout.setContentsMargins(10, 15, 10, 10) + self._uart_group.setLayout(uart_layout) + self._uart_group.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) + + uart_row = 0 + + # Port + uart_layout.addWidget(QLabel("Port:"), uart_row, 0, Qt.AlignRight) + self._port_combo = QComboBox() + self._port_combo.setFixedWidth(120) + uart_layout.addWidget(self._port_combo, uart_row, 1) + + # Refresh button + self._refresh_btn = QPushButton() + self._refresh_btn.setFixedSize(25, 25) + refresh_icon = os.path.join(os.path.dirname(img_src.__file__), "refresh.png") + if os.path.exists(refresh_icon): + self._refresh_btn.setIcon(QIcon(refresh_icon)) + uart_layout.addWidget(self._refresh_btn, uart_row, 2) + uart_row += 1 + + # Baud Rate + uart_layout.addWidget(QLabel("Baud Rate:"), uart_row, 0, Qt.AlignRight) + self._baud_combo = QComboBox() + self._baud_combo.setFixedWidth(120) + self._baud_combo.addItems(["38400", "115200", "230400", "460800", "921600"]) + self._baud_combo.setCurrentText("115200") + uart_layout.addWidget(self._baud_combo, uart_row, 1) + + left_layout.addWidget(self._uart_group) + + # === TCP/IP Settings Group === + self._tcp_group = QGroupBox("TCP/IP Settings") + tcp_layout = QGridLayout() + tcp_layout.setSpacing(8) + tcp_layout.setContentsMargins(10, 15, 10, 10) + self._tcp_group.setLayout(tcp_layout) + self._tcp_group.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) + + tcp_row = 0 + + # Host (IP address or hostname) + tcp_layout.addWidget(QLabel("Host:"), tcp_row, 0, Qt.AlignRight) + self._ip_edit = QLineEdit("192.168.0.100") + self._ip_edit.setFixedWidth(120) + self._ip_edit.setPlaceholderText("IP or hostname") + # Validator for IP address or hostname (alphanumeric, dots, hyphens) + host_regex = QRegExp(r"^[a-zA-Z0-9][a-zA-Z0-9.\-]*$") + self._ip_edit.setValidator(QRegExpValidator(host_regex)) + tcp_layout.addWidget(self._ip_edit, tcp_row, 1) + tcp_row += 1 + + # Port (numbers only, 1-65535) + tcp_layout.addWidget(QLabel("Port:"), tcp_row, 0, Qt.AlignRight) + self._tcp_port_edit = QLineEdit("12666") + self._tcp_port_edit.setFixedWidth(120) + self._tcp_port_edit.setValidator(QIntValidator(1, 65535)) + tcp_layout.addWidget(self._tcp_port_edit, tcp_row, 1) + + left_layout.addWidget(self._tcp_group) + + # === CAN Settings Group === + self._can_group = QGroupBox("CAN Settings") + can_layout = QGridLayout() + can_layout.setSpacing(8) + can_layout.setContentsMargins(10, 15, 10, 10) + self._can_group.setLayout(can_layout) + self._can_group.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) + + can_row = 0 + + # Bus Type + can_layout.addWidget(QLabel("Bus Type:"), can_row, 0, Qt.AlignRight) + self._can_bus_type_combo = QComboBox() + self._can_bus_type_combo.addItems(["USB", "LAN"]) + self._can_bus_type_combo.setFixedWidth(120) + can_layout.addWidget(self._can_bus_type_combo, can_row, 1) + can_row += 1 + + # Channel (numbers only) + can_layout.addWidget(QLabel("Channel:"), can_row, 0, Qt.AlignRight) + self._can_channel_edit = QLineEdit("1") + self._can_channel_edit.setFixedWidth(120) + self._can_channel_edit.setValidator(QIntValidator(0, 255)) + can_layout.addWidget(self._can_channel_edit, can_row, 1) + can_row += 1 + + # Baudrate + can_layout.addWidget(QLabel("Baudrate:"), can_row, 0, Qt.AlignRight) + self._can_baudrate_combo = QComboBox() + self._can_baudrate_combo.addItems(["125K", "250K", "500K", "1M"]) + self._can_baudrate_combo.setCurrentText("125K") + self._can_baudrate_combo.setFixedWidth(120) + can_layout.addWidget(self._can_baudrate_combo, can_row, 1) + can_row += 1 + + # Mode + can_layout.addWidget(QLabel("Mode:"), can_row, 0, Qt.AlignRight) + self._can_mode_combo = QComboBox() + self._can_mode_combo.addItems(["Standard", "Extended"]) + self._can_mode_combo.setFixedWidth(120) + can_layout.addWidget(self._can_mode_combo, can_row, 1) + can_row += 1 + + # Tx-ID (hex) + can_layout.addWidget(QLabel("Tx-ID (hex):"), can_row, 0, Qt.AlignRight) + self._can_tx_id_edit = QLineEdit("7F1") + self._can_tx_id_edit.setFixedWidth(120) + can_layout.addWidget(self._can_tx_id_edit, can_row, 1) + can_row += 1 + + # Rx-ID (hex) + can_layout.addWidget(QLabel("Rx-ID (hex):"), can_row, 0, Qt.AlignRight) + self._can_rx_id_edit = QLineEdit("7F0") + self._can_rx_id_edit.setFixedWidth(120) + can_layout.addWidget(self._can_rx_id_edit, can_row, 1) + + left_layout.addWidget(self._can_group) + left_layout.addStretch() + + main_layout.addLayout(left_layout) + + # Add spacing between groups + main_layout.addSpacing(20) + + # Right side: Device info (aligned to top) + right_layout = QVBoxLayout() + right_layout.setAlignment(Qt.AlignTop) + + device_group = QGroupBox("Device Information") + device_layout = QGridLayout() + device_layout.setSpacing(5) + device_layout.setContentsMargins(10, 15, 10, 10) + device_group.setLayout(device_layout) + device_group.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed) + + self._device_info_labels = { + "processor_id": QLabel("Not connected"), + "uc_width": QLabel("Not connected"), + "date": QLabel("Not connected"), + "time": QLabel("Not connected"), + "appVer": QLabel("Not connected"), + "dsp_state": QLabel("Not connected"), + } + + info_titles = { + "processor_id": "Processor ID:", + "uc_width": "UC Width:", + "date": "Date:", + "time": "Time:", + "appVer": "App Version:", + "dsp_state": "DSP State:", + } + + for i, (key, label) in enumerate(self._device_info_labels.items()): + title_label = QLabel(info_titles[key]) + title_label.setAlignment(Qt.AlignRight) + device_layout.addWidget(title_label, i, 0, Qt.AlignRight) + label.setMinimumWidth(150) + device_layout.addWidget(label, i, 1, Qt.AlignLeft) + + right_layout.addWidget(device_group) + right_layout.addStretch() + + main_layout.addLayout(right_layout) + + # Add stretch to push everything to the left + main_layout.addStretch() + + # Set initial interface visibility + self._on_interface_changed("UART") + + def _on_interface_changed(self, interface: str): + """Handle interface selection change.""" + # Hide all interface settings groups + self._uart_group.hide() + self._tcp_group.hide() + self._can_group.hide() + + # Show relevant group based on interface + if interface == "UART": + self._uart_group.show() + elif interface == "TCP/IP": + self._tcp_group.show() + elif interface == "CAN": + self._can_group.show() + + def _on_select_elf(self): + """Handle ELF file selection.""" + # Get last directory from settings + last_dir = self._settings.value("elf_file_dir", "", type=str) + + file_path, _ = QFileDialog.getOpenFileName( + self, + "Select ELF File", + last_dir, + "ELF Files (*.elf);;All Files (*.*)", + ) + if file_path: + self._elf_file_path = file_path + # Save the directory for next time + self._settings.setValue("elf_file_dir", os.path.dirname(file_path)) + # Show shortened filename + basename = os.path.basename(file_path) + if len(basename) > self.MAX_FILENAME_DISPLAY_LENGTH: + basename = basename[: self.MAX_FILENAME_DISPLAY_LENGTH - 3] + "..." + self._elf_button.setText(basename) + self._elf_button.setToolTip(file_path) + self.elf_file_selected.emit(file_path) + + # Public properties and methods + + @property + def interface_type(self) -> str: + """Get the selected interface type.""" + return self._interface_combo.currentText() + + @property + def port_combo(self) -> QComboBox: + """Get the port combo box.""" + return self._port_combo + + @property + def baud_combo(self) -> QComboBox: + """Get the baud rate combo box.""" + return self._baud_combo + + @property + def ip_address(self) -> str: + """Get the IP address.""" + return self._ip_edit.text() + + @property + def tcp_port(self) -> int: + """Get the TCP port.""" + try: + return int(self._tcp_port_edit.text()) + except ValueError: + return 12666 + + @property + def connect_btn(self) -> QPushButton: + """Get the connect button.""" + return self._connect_btn + + @property + def refresh_btn(self) -> QPushButton: + """Get the refresh button.""" + return self._refresh_btn + + @property + def elf_file_path(self) -> str: + """Get the selected ELF file path.""" + return self._elf_file_path + + @elf_file_path.setter + def elf_file_path(self, path: str): + """Set the ELF file path.""" + self._elf_file_path = path + if path: + basename = os.path.basename(path) + if len(basename) > self.MAX_FILENAME_DISPLAY_LENGTH: + basename = basename[: self.MAX_FILENAME_DISPLAY_LENGTH - 3] + "..." + self._elf_button.setText(basename) + self._elf_button.setToolTip(path) + + def set_ports(self, ports: list): + """Set available COM ports.""" + self._port_combo.clear() + self._port_combo.addItems(ports) + + def set_connected(self, connected: bool): + """Update UI for connection state.""" + # Hide loading label + self._loading_label.hide() + self._connect_btn.setEnabled(True) + + self._connect_btn.setText("Disconnect" if connected else "Connect") + + # Disable/enable interface selection and ELF button + self._interface_combo.setEnabled(not connected) + self._elf_button.setEnabled(not connected) + + # Disable/enable interface settings groups when connected + self._uart_group.setEnabled(not connected) + self._tcp_group.setEnabled(not connected) + self._can_group.setEnabled(not connected) + + def set_loading(self, loading: bool): + """Show or hide the loading indicator.""" + if loading: + self._loading_label.show() + self._connect_btn.setEnabled(False) + else: + self._loading_label.hide() + self._connect_btn.setEnabled(True) + + def _on_connect_clicked(self): + """Handle connect button click - show loading and emit signal.""" + self.set_loading(True) + self.connect_requested.emit() + + def update_device_info(self, device_info): + """Update device info labels.""" + if device_info: + self._device_info_labels["processor_id"].setText(device_info.processor_id) + self._device_info_labels["uc_width"].setText(device_info.uc_width) + self._device_info_labels["date"].setText(device_info.date) + self._device_info_labels["time"].setText(device_info.time) + self._device_info_labels["appVer"].setText(device_info.app_ver) + self._device_info_labels["dsp_state"].setText(device_info.dsp_state) + + def clear_device_info(self): + """Clear device info labels.""" + for label in self._device_info_labels.values(): + label.setText("Not connected") + + def get_connection_params(self) -> dict: + """Get connection parameters based on selected interface.""" + interface = self.interface_type + params = {"interface": interface} + + if interface == "UART": + params["port"] = self._port_combo.currentText() + params["baud_rate"] = int(self._baud_combo.currentText()) + elif interface == "TCP/IP": + params["host"] = self._ip_edit.text() + params["tcp_port"] = self.tcp_port + elif interface == "CAN": + params["bus_type"] = self._can_bus_type_combo.currentText() + params["channel"] = int(self._can_channel_edit.text()) + params["baudrate"] = self._can_baudrate_combo.currentText() + params["mode"] = self._can_mode_combo.currentText() + params["tx_id"] = self._can_tx_id_edit.text() + params["rx_id"] = self._can_rx_id_edit.text() + + return params + + def set_interface(self, interface: str): + """Set the interface type.""" + index = self._interface_combo.findText(interface) + if index >= 0: + self._interface_combo.setCurrentIndex(index) + + def set_connection_params(self, params: dict): + """Set connection parameters from config.""" + interface = params.get("interface", "UART") + self.set_interface(interface) + + if interface == "UART": + if "baud_rate" in params: + self._baud_combo.setCurrentText(str(params["baud_rate"])) + elif interface == "TCP/IP": + if "host" in params: + self._ip_edit.setText(params["host"]) + if "port" in params: + self._tcp_port_edit.setText(str(params["port"])) + elif interface == "CAN": + if "bus_type" in params: + self._can_bus_type_combo.setCurrentText(params["bus_type"]) + if "channel" in params: + self._can_channel_edit.setText(str(params["channel"])) + if "baudrate" in params: + self._can_baudrate_combo.setCurrentText(params["baudrate"]) + if "mode" in params: + self._can_mode_combo.setCurrentText(params["mode"]) + if "tx_id" in params: + self._can_tx_id_edit.setText(params["tx_id"]) + if "rx_id" in params: + self._can_rx_id_edit.setText(params["rx_id"]) + + def save_connection_settings(self): + """Save current connection settings to persistent storage.""" + self._settings.setValue("connection/interface", self._interface_combo.currentText()) + + # UART settings + self._settings.setValue("connection/uart_baud", self._baud_combo.currentText()) + + # TCP/IP settings + self._settings.setValue("connection/tcp_host", self._ip_edit.text()) + self._settings.setValue("connection/tcp_port", self._tcp_port_edit.text()) + + # CAN settings + self._settings.setValue("connection/can_bus_type", self._can_bus_type_combo.currentText()) + self._settings.setValue("connection/can_channel", self._can_channel_edit.text()) + self._settings.setValue("connection/can_baudrate", self._can_baudrate_combo.currentText()) + self._settings.setValue("connection/can_mode", self._can_mode_combo.currentText()) + self._settings.setValue("connection/can_tx_id", self._can_tx_id_edit.text()) + self._settings.setValue("connection/can_rx_id", self._can_rx_id_edit.text()) + + def _restore_connection_settings(self): + """Restore connection settings from persistent storage.""" + # Restore interface type + interface = self._settings.value("connection/interface", "UART", type=str) + self.set_interface(interface) + + # Restore UART settings + baud = self._settings.value("connection/uart_baud", "115200", type=str) + self._baud_combo.setCurrentText(baud) + + # Restore TCP/IP settings + host = self._settings.value("connection/tcp_host", "192.168.0.100", type=str) + self._ip_edit.setText(host) + tcp_port = self._settings.value("connection/tcp_port", "12666", type=str) + self._tcp_port_edit.setText(tcp_port) + + # Restore CAN settings + bus_type = self._settings.value("connection/can_bus_type", "USB", type=str) + self._can_bus_type_combo.setCurrentText(bus_type) + channel = self._settings.value("connection/can_channel", "1", type=str) + self._can_channel_edit.setText(channel) + baudrate = self._settings.value("connection/can_baudrate", "125K", type=str) + self._can_baudrate_combo.setCurrentText(baudrate) + mode = self._settings.value("connection/can_mode", "Standard", type=str) + self._can_mode_combo.setCurrentText(mode) + tx_id = self._settings.value("connection/can_tx_id", "7F1", type=str) + self._can_tx_id_edit.setText(tx_id) + rx_id = self._settings.value("connection/can_rx_id", "7F0", type=str) + self._can_rx_id_edit.setText(rx_id) diff --git a/pyx2cscope/gui/qt/tabs/watch_view_tab.py b/pyx2cscope/gui/qt/tabs/watch_view_tab.py new file mode 100644 index 00000000..662ea245 --- /dev/null +++ b/pyx2cscope/gui/qt/tabs/watch_view_tab.py @@ -0,0 +1,374 @@ +"""WatchView tab (Tab3) - Dynamic watch variables without plotting.""" + +import logging +from typing import TYPE_CHECKING, List, Tuple + +from PyQt5 import QtCore +from PyQt5.QtCore import Qt, pyqtSignal, pyqtSlot +from PyQt5.QtWidgets import ( + QCheckBox, + QDialog, + QGridLayout, + QLabel, + QLineEdit, + QPushButton, + QScrollArea, + QSizePolicy, + QVBoxLayout, + QWidget, +) + +from pyx2cscope.gui.qt.dialogs.variable_selection import VariableSelectionDialog +from pyx2cscope.gui.qt.tabs.base_tab import BaseTab + +if TYPE_CHECKING: + from pyx2cscope.gui.qt.models.app_state import AppState + + +class WatchViewTab(BaseTab): + """Tab for dynamically adding/removing watch variables. + + Features: + - Dynamic row addition/removal + - Live polling for checked variables + - Scaling and offset calculations + - Scrollable interface for many variables + """ + + # Signal emitted when live polling state changes: (index, is_live) + live_polling_changed = pyqtSignal(int, bool) + + def __init__(self, app_state: "AppState", parent=None): + """Initialize the WatchView tab. + + Args: + app_state: The centralized application state. + parent: Optional parent widget. + """ + super().__init__(app_state, parent) + self._variable_list: List[str] = [] + self._current_row = 1 + + # Widget lists for each row + self._row_widgets: List[Tuple] = [] + self._live_checkboxes: List[QCheckBox] = [] + self._variable_edits: List[QLineEdit] = [] + self._value_edits: List[QLineEdit] = [] + self._scaling_edits: List[QLineEdit] = [] + self._offset_edits: List[QLineEdit] = [] + self._scaled_value_edits: List[QLineEdit] = [] + self._unit_edits: List[QLineEdit] = [] + + self._setup_ui() + + def _setup_ui(self): + """Set up the user interface.""" + # Set white background + self.setAutoFillBackground(True) + self.setStyleSheet("background-color: white;") + + main_layout = QVBoxLayout() + self.setLayout(main_layout) + + # Scroll area + scroll_area = QScrollArea() + scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) + scroll_widget = QWidget() + scroll_layout = QVBoxLayout(scroll_widget) + scroll_area.setWidget(scroll_widget) + scroll_area.setWidgetResizable(True) + main_layout.addWidget(scroll_area) + + # Grid layout for variable rows + self._grid_layout = QGridLayout() + self._grid_layout.setContentsMargins(0, 0, 0, 0) + self._grid_layout.setVerticalSpacing(2) + self._grid_layout.setHorizontalSpacing(5) + scroll_layout.addLayout(self._grid_layout) + + # Headers + headers = ["Live", "Variable", "Value", "Scaling", "Offset", "Scaled Value", "Unit", "Remove"] + for col, header in enumerate(headers): + label = QLabel(header) + label.setAlignment(Qt.AlignCenter) + label.setSizePolicy(QSizePolicy.Minimum, QSizePolicy.Fixed) + self._grid_layout.addWidget(label, 0, col) + + # Set column stretch + self._grid_layout.setColumnStretch(1, 5) # Variable + self._grid_layout.setColumnStretch(2, 2) # Value + self._grid_layout.setColumnStretch(3, 1) # Scaling + self._grid_layout.setColumnStretch(4, 1) # Offset + self._grid_layout.setColumnStretch(5, 1) # Scaled Value + self._grid_layout.setColumnStretch(6, 1) # Unit + + # Add Variable button + self._add_button = QPushButton("Add Variable") + self._add_button.clicked.connect(self._add_variable_row) + scroll_layout.addWidget(self._add_button) + + # Add stretch to push content to top + scroll_layout.addStretch() + + scroll_layout.setContentsMargins(0, 0, 0, 0) + + def on_connection_changed(self, connected: bool): + """Handle connection state changes.""" + self._add_button.setEnabled(connected) + for var_edit in self._variable_edits: + var_edit.setEnabled(connected) + + def on_variable_list_updated(self, variables: list): + """Handle variable list updates.""" + self._variable_list = variables + + def eventFilter(self, source, event): # noqa: N802 + """Event filter to handle line edit click events for variable selection.""" + if event.type() == QtCore.QEvent.MouseButtonPress: + if isinstance(source, QLineEdit) and source in self._variable_edits: + index = self._variable_edits.index(source) + self._on_variable_click(index) + return True # Consume the event after handling + return super().eventFilter(source, event) + + def _add_variable_row(self): + """Add a new variable row to the grid.""" + row = self._current_row + index = len(self._row_widgets) + + # Create widgets + live_cb = QCheckBox() + live_cb.stateChanged.connect(lambda state, idx=index: self._on_live_changed(idx, state)) + + var_edit = QLineEdit() + var_edit.setPlaceholderText("Search Variable") + var_edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) + var_edit.setEnabled(self._app_state.is_connected()) # Enable based on connection state + var_edit.installEventFilter(self) + + value_edit = QLineEdit() + value_edit.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Preferred) + value_edit.editingFinished.connect(lambda idx=index: self._on_value_changed(idx)) + + scaling_edit = QLineEdit("1") + scaling_edit.editingFinished.connect(lambda idx=index: self._update_scaled_value(idx)) + + offset_edit = QLineEdit("0") + offset_edit.editingFinished.connect(lambda idx=index: self._update_scaled_value(idx)) + + scaled_value_edit = QLineEdit() + scaled_value_edit.setReadOnly(True) + + unit_edit = QLineEdit() + + remove_btn = QPushButton("Remove") + remove_btn.clicked.connect(lambda checked, idx=index: self._remove_variable_row(idx)) + + # Add to grid + self._grid_layout.addWidget(live_cb, row, 0) + self._grid_layout.addWidget(var_edit, row, 1) + self._grid_layout.addWidget(value_edit, row, 2) + self._grid_layout.addWidget(scaling_edit, row, 3) + self._grid_layout.addWidget(offset_edit, row, 4) + self._grid_layout.addWidget(scaled_value_edit, row, 5) + self._grid_layout.addWidget(unit_edit, row, 6) + self._grid_layout.addWidget(remove_btn, row, 7) + + # Track widgets + widgets = (live_cb, var_edit, value_edit, scaling_edit, offset_edit, scaled_value_edit, unit_edit, remove_btn) + self._row_widgets.append(widgets) + self._live_checkboxes.append(live_cb) + self._variable_edits.append(var_edit) + self._value_edits.append(value_edit) + self._scaling_edits.append(scaling_edit) + self._offset_edits.append(offset_edit) + self._scaled_value_edits.append(scaled_value_edit) + self._unit_edits.append(unit_edit) + + # Add to app state + self._app_state.add_live_watch_var() + + self._current_row += 1 + + # Calculate initial scaled value + self._update_scaled_value(index) + + def _remove_variable_row(self, index: int): + """Remove a variable row from the grid.""" + if index >= len(self._row_widgets): + return + + # Get widgets to remove + widgets = self._row_widgets[index] + + # Remove from grid and delete + for widget in widgets: + self._grid_layout.removeWidget(widget) + widget.deleteLater() + + # Remove from tracking lists + self._row_widgets.pop(index) + self._live_checkboxes.pop(index) + self._variable_edits.pop(index) + self._value_edits.pop(index) + self._scaling_edits.pop(index) + self._offset_edits.pop(index) + self._scaled_value_edits.pop(index) + self._unit_edits.pop(index) + + # Remove from app state + self._app_state.remove_live_watch_var(index) + + self._current_row -= 1 + + # Rearrange grid + self._rearrange_grid() + + def _rearrange_grid(self): + """Rearrange the grid after row removal.""" + # Remove all widgets from grid + for i in reversed(range(self._grid_layout.count())): + widget = self._grid_layout.itemAt(i).widget() + if widget: + widget.setParent(None) + + # Re-add headers + headers = ["Live", "Variable", "Value", "Scaling", "Offset", "Scaled Value", "Unit", "Remove"] + for col, header in enumerate(headers): + self._grid_layout.addWidget(QLabel(header), 0, col) + + # Re-add rows + for row, widgets in enumerate(self._row_widgets, start=1): + for col, widget in enumerate(widgets): + self._grid_layout.addWidget(widget, row, col) + + # Update remove button connections + for i, widgets in enumerate(self._row_widgets): + remove_btn = widgets[7] + remove_btn.clicked.disconnect() + remove_btn.clicked.connect(lambda checked, idx=i: self._remove_variable_row(idx)) + + def _on_variable_click(self, index: int): + """Handle click on variable field to open selection dialog.""" + if not self._variable_list or index >= len(self._variable_edits): + return + + sfr_list = self._app_state.get_sfr_list() + dialog = VariableSelectionDialog(self._variable_list, self, sfr_variables=sfr_list) + if dialog.exec_() == QDialog.Accepted and dialog.selected_variable: + sfr = dialog.sfr_selected + self._variable_edits[index].setText(dialog.selected_variable) + # Store sfr flag before updating name so the var_ref cache uses the right namespace + self._app_state.update_live_watch_var_field(index, "sfr", sfr) + self._app_state.update_live_watch_var_field(index, "name", dialog.selected_variable) + + # Read initial value + value = self._app_state.read_variable(dialog.selected_variable, sfr=sfr) + if value is not None: + self._value_edits[index].setText(str(value)) + self._app_state.update_live_watch_var_field(index, "value", value) + self._update_scaled_value(index) + + def _on_live_changed(self, index: int, state: int): + """Handle live checkbox state change.""" + if index >= len(self._live_checkboxes): + return + is_live = state == Qt.Checked + self._app_state.update_live_watch_var_field(index, "live", is_live) + # Emit signal to notify DataPoller + self.live_polling_changed.emit(index, is_live) + + def _on_value_changed(self, index: int): + """Handle value edit finished - write to device.""" + if index >= len(self._variable_edits): + return + + var_name = self._variable_edits[index].text() + if var_name and var_name != "None": + try: + value = float(self._value_edits[index].text()) + sfr = self._app_state.get_live_watch_var(index).sfr + self._app_state.write_variable(var_name, value, sfr=sfr) + except ValueError: + pass + + def _update_scaled_value(self, index: int): + """Update the scaled value for a variable.""" + if index >= len(self._value_edits): + return + + try: + value = self.safe_float(self._value_edits[index].text()) + scaling = self.safe_float(self._scaling_edits[index].text(), 1.0) + offset = self.safe_float(self._offset_edits[index].text()) + scaled = self.calculate_scaled_value(value, scaling, offset) + self._scaled_value_edits[index].setText(f"{scaled:.2f}") + except Exception as e: + logging.error(f"Error updating scaled value: {e}") + self._scaled_value_edits[index].setText("0.00") + + @pyqtSlot(int, str, float) + def on_live_var_updated(self, index: int, name: str, value: float): + """Handle live variable update from data poller. + + Args: + index: Variable index. + name: Variable name. + value: New value. + """ + if index < len(self._value_edits): + self._value_edits[index].setText(str(value)) + self._update_scaled_value(index) + + def clear_all_rows(self): + """Clear all variable rows.""" + while self._row_widgets: + self._remove_variable_row(0) + + def get_config(self) -> dict: + """Get the current tab configuration.""" + return { + "variables": [le.text() for le in self._variable_edits], + "values": [ve.text() for ve in self._value_edits], + "scaling": [sc.text() for sc in self._scaling_edits], + "offsets": [off.text() for off in self._offset_edits], + "scaled_values": [sv.text() for sv in self._scaled_value_edits], + "live": [cb.isChecked() for cb in self._live_checkboxes], + } + + def load_config(self, config: dict): + """Load configuration into the tab.""" + # Clear existing rows + self.clear_all_rows() + + # Add rows for each variable + variables = config.get("variables", []) + values = config.get("values", []) + scalings = config.get("scaling", []) + offsets = config.get("offsets", []) + scaled_values = config.get("scaled_values", []) + lives = config.get("live", []) + + for i, var in enumerate(variables): + self._add_variable_row() + if i < len(self._variable_edits): + self._variable_edits[i].setText(var) + # Update app state with variable name + self._app_state.update_live_watch_var_field(i, "name", var) + if i < len(values) and i < len(self._value_edits): + self._value_edits[i].setText(values[i]) + if i < len(scalings) and i < len(self._scaling_edits): + self._scaling_edits[i].setText(scalings[i]) + if i < len(offsets) and i < len(self._offset_edits): + self._offset_edits[i].setText(offsets[i]) + if i < len(scaled_values) and i < len(self._scaled_value_edits): + self._scaled_value_edits[i].setText(scaled_values[i]) + if i < len(lives) and i < len(self._live_checkboxes): + self._live_checkboxes[i].setChecked(lives[i]) + # Update app state with live state + self._app_state.update_live_watch_var_field(i, "live", lives[i]) + + @property + def row_count(self) -> int: + """Get the number of variable rows.""" + return len(self._row_widgets) diff --git a/pyx2cscope/gui/qt/workers/__init__.py b/pyx2cscope/gui/qt/workers/__init__.py new file mode 100644 index 00000000..a616c7a7 --- /dev/null +++ b/pyx2cscope/gui/qt/workers/__init__.py @@ -0,0 +1,5 @@ +"""Background worker threads for the generic GUI.""" + +from .data_poller import DataPoller + +__all__ = ["DataPoller"] diff --git a/pyx2cscope/gui/qt/workers/data_poller.py b/pyx2cscope/gui/qt/workers/data_poller.py new file mode 100644 index 00000000..2be2d834 --- /dev/null +++ b/pyx2cscope/gui/qt/workers/data_poller.py @@ -0,0 +1,274 @@ +"""Background worker thread for data polling. + +This module consolidates all timer-based polling into a single QThread, +replacing the 7 separate QTimer instances from the original implementation. +""" + +import logging +import time +from typing import List + +from PyQt5.QtCore import QMutex, QThread, pyqtSignal + + +class DataPoller(QThread): + """Background thread for polling watch variables and scope data. + + Consolidates polling for: + - Tab1: Watch variables (previously timer1-5) + - Tab1: Plot data updates (previously plot_update_timer) + - Tab2: Scope data sampling (previously scope_timer) + - Tab3: Live variable updates (previously live_update_timer) + + Signals: + watch_var_updated: Emitted when a watch variable value is read. + Args: (index: int, name: str, value: float) + scope_data_ready: Emitted when scope data is available. + Args: (data: dict) + live_var_updated: Emitted when a Tab3 live variable is read. + Args: (index: int, name: str, value: float) + error_occurred: Emitted when an error occurs during polling. + Args: (message: str) + """ + + # Signals for thread-safe UI updates + watch_var_updated = pyqtSignal(int, str, float) # index, name, value + scope_data_ready = pyqtSignal(dict) # channel_data + live_var_updated = pyqtSignal(int, str, float) # index, name, value + error_occurred = pyqtSignal(str) # error message + plot_data_ready = pyqtSignal() # signal to update plot + + def __init__(self, app_state, parent=None): + """Initialize the data poller. + + Args: + app_state: The centralized AppState instance. + parent: Optional parent QObject. + """ + super().__init__(parent) + self._app_state = app_state + self._mutex = QMutex() + self._running = False + + # Polling intervals (ms) + self._watch_interval_ms = 500 + self._scope_interval_ms = 250 + self._live_interval_ms = 500 + + # Enable flags for different polling tasks + self._watch_polling_enabled = False + self._scope_polling_enabled = False + self._live_polling_enabled = False + self._scope_single_shot = False + + # Track which watch variables are active (Tab1) + self._active_watch_indices: List[int] = [] + + # Track which live variables are active (Tab3) + self._active_live_indices: List[int] = [] + + def run(self): + """Main thread loop - polls data at configured intervals.""" + self._running = True + logging.debug("DataPoller thread started") + + # Track last poll times + last_watch_poll = 0.0 + last_scope_poll = 0.0 + last_live_poll = 0.0 + + while self._running: + current_time = time.time() * 1000 # Convert to ms + + try: + # Poll watch variables (Tab1) + if self._watch_polling_enabled: + if current_time - last_watch_poll >= self._watch_interval_ms: + self._poll_watch_variables() + last_watch_poll = current_time + + # Poll scope data (Tab2) + if self._scope_polling_enabled: + if current_time - last_scope_poll >= self._scope_interval_ms: + self._poll_scope_data() + last_scope_poll = current_time + + # Poll live variables (Tab3) + if self._live_polling_enabled: + if current_time - last_live_poll >= self._live_interval_ms: + self._poll_live_variables() + last_live_poll = current_time + + except Exception as e: + logging.error(f"DataPoller error: {e}") + self.error_occurred.emit(str(e)) + + # Sleep to prevent busy-waiting (10ms granularity) + self.msleep(10) + + def stop(self): + """Stop the polling thread.""" + self._running = False + self.wait() + + # ============= Watch Variables (Tab1) ============= + + def set_watch_polling_enabled(self, enabled: bool): + """Enable or disable watch variable polling.""" + self._mutex.lock() + self._watch_polling_enabled = enabled + self._mutex.unlock() + + def set_active_watch_indices(self, indices: List[int]): + """Set which watch variable indices should be polled.""" + self._mutex.lock() + self._active_watch_indices = indices.copy() + self._mutex.unlock() + + def add_active_watch_index(self, index: int): + """Add a watch variable index to active polling.""" + logging.debug(f"add_active_watch_index: adding index {index}") + self._mutex.lock() + if index not in self._active_watch_indices: + self._active_watch_indices.append(index) + self._watch_polling_enabled = len(self._active_watch_indices) > 0 + logging.debug(f"add_active_watch_index: enabled={self._watch_polling_enabled}, indices={self._active_watch_indices}") + self._mutex.unlock() + + def remove_active_watch_index(self, index: int): + """Remove a watch variable index from active polling.""" + self._mutex.lock() + if index in self._active_watch_indices: + self._active_watch_indices.remove(index) + self._watch_polling_enabled = len(self._active_watch_indices) > 0 + self._mutex.unlock() + + def _poll_watch_variables(self): + """Poll all active watch variables.""" + if not self._app_state.is_connected(): + logging.debug("_poll_watch_variables: not connected") + return + + self._mutex.lock() + indices = self._active_watch_indices.copy() + self._mutex.unlock() + + logging.debug(f"_poll_watch_variables: polling indices {indices}") + for index in indices: + watch_var = self._app_state.get_watch_var(index) + logging.debug(f"_poll_watch_variables: index={index}, name='{watch_var.name}'") + if watch_var.name and watch_var.name != "None": + # Use cached var_ref for faster polling + value = self._app_state.read_watch_var_value(index) + logging.debug(f"_poll_watch_variables: read value={value}") + if value is not None: + self._app_state.update_watch_var_field(index, "value", value) + self.watch_var_updated.emit(index, watch_var.name, value) + + # Signal plot update after all variables polled + if indices: + self.plot_data_ready.emit() + + # ============= Scope Data (Tab2) ============= + + def set_scope_polling_enabled(self, enabled: bool, single_shot: bool = False): + """Enable or disable scope data polling.""" + self._mutex.lock() + self._scope_polling_enabled = enabled + self._scope_single_shot = single_shot + self._mutex.unlock() + + def _poll_scope_data(self): + """Poll scope data if ready.""" + if not self._app_state.is_connected(): + return + + if self._app_state.is_scope_data_ready(): + data = self._app_state.get_scope_channel_data() + if data: + self.scope_data_ready.emit(data) + + # Handle single-shot mode + self._mutex.lock() + is_single_shot = self._scope_single_shot + self._mutex.unlock() + + if is_single_shot: + self.set_scope_polling_enabled(False) + else: + # Request next data + self._app_state.request_scope_data() + + # ============= Live Variables (Tab3) ============= + + def set_live_polling_enabled(self, enabled: bool): + """Enable or disable live variable polling (Tab3).""" + self._mutex.lock() + self._live_polling_enabled = enabled + self._mutex.unlock() + + def set_active_live_indices(self, indices: List[int]): + """Set which live variable indices should be polled.""" + self._mutex.lock() + self._active_live_indices = indices.copy() + self._mutex.unlock() + + def add_active_live_index(self, index: int): + """Add a live variable index to active polling.""" + logging.debug(f"add_active_live_index: adding index {index}") + self._mutex.lock() + if index not in self._active_live_indices: + self._active_live_indices.append(index) + self._live_polling_enabled = len(self._active_live_indices) > 0 + logging.debug(f"add_active_live_index: enabled={self._live_polling_enabled}, indices={self._active_live_indices}") + self._mutex.unlock() + + def remove_active_live_index(self, index: int): + """Remove a live variable index from active polling.""" + self._mutex.lock() + if index in self._active_live_indices: + self._active_live_indices.remove(index) + self._live_polling_enabled = len(self._active_live_indices) > 0 + self._mutex.unlock() + + def _poll_live_variables(self): + """Poll all active live variables (Tab3).""" + if not self._app_state.is_connected(): + logging.debug("_poll_live_variables: not connected") + return + + self._mutex.lock() + indices = self._active_live_indices.copy() + self._mutex.unlock() + + logging.debug(f"_poll_live_variables: polling indices {indices}") + for index in indices: + live_var = self._app_state.get_live_watch_var(index) + logging.debug(f"_poll_live_variables: index={index}, name='{live_var.name}'") + if live_var.name and live_var.name != "None": + # Use cached var_ref for faster polling + value = self._app_state.read_live_watch_var_value(index) + logging.debug(f"_poll_live_variables: read value={value}") + if value is not None: + self._app_state.update_live_watch_var_field(index, "value", value) + self.live_var_updated.emit(index, live_var.name, value) + + # ============= Interval Configuration ============= + + def set_watch_interval(self, interval_ms: int): + """Set the watch variable polling interval.""" + self._mutex.lock() + self._watch_interval_ms = max(50, interval_ms) + self._mutex.unlock() + + def set_scope_interval(self, interval_ms: int): + """Set the scope data polling interval.""" + self._mutex.lock() + self._scope_interval_ms = max(50, interval_ms) + self._mutex.unlock() + + def set_live_interval(self, interval_ms: int): + """Set the live variable polling interval.""" + self._mutex.lock() + self._live_interval_ms = max(50, interval_ms) + self._mutex.unlock() diff --git a/pyx2cscope/gui/resources/__init__.py b/pyx2cscope/gui/resources/__init__.py new file mode 100644 index 00000000..73345094 --- /dev/null +++ b/pyx2cscope/gui/resources/__init__.py @@ -0,0 +1,10 @@ +"""Shared resources for Qt and Web GUIs.""" + +import os + +RESOURCES_DIR = os.path.dirname(__file__) + + +def get_resource_path(filename: str) -> str: + """Get the full path to a resource file.""" + return os.path.join(RESOURCES_DIR, filename) diff --git a/pyx2cscope/gui/resources/script_help.md b/pyx2cscope/gui/resources/script_help.md new file mode 100644 index 00000000..13b773de --- /dev/null +++ b/pyx2cscope/gui/resources/script_help.md @@ -0,0 +1,138 @@ +This Scripting Section allows you to run Python scripts without the use of an IDE. You can load Python scripts and run them standalone as the examples available under PyX2Cscope examples folder. Otherwise you can take advantage of this App and use the Setup tab to connect to your device. Doing this, the script has access to the x2cscope connection and some methods as described below. + +For further information, check the PyX2Cscope scripting documentation at: + +[https://x2cscope.github.io/pyx2cscope/scripting.html](https://x2cscope.github.io/pyx2cscope/scripting.html) + + +## Available Objects/Functions + +- **x2cscope** - The X2CScope instance (or `None` if not connected) +- **stop_requested()** - Returns `True` when Stop button is pressed + +--- + +## Basic Example + +```python +var = x2cscope.get_variable("myVariable") +value = var.get_value() +print(f"Current value: {value}") +``` + +## Write a Value + +```python +var = x2cscope.get_variable("myVariable") +var.set_value(123.45) +print("Value written successfully") +``` + +## Read Multiple Variables + +```python +variables = ["var1", "var2", "var3"] +for name in variables: + var = x2cscope.get_variable(name) + if var: + print(f"{name} = {var.get_value()}") +``` + +## List All Variables + +```python +all_vars = x2cscope.list_variables() +for name in all_vars[:10]: # First 10 + print(name) +``` + +--- + +## Loop with Stop Support + +Use `stop_requested()` to make your loops respond to the **Stop** button: + +```python +import time + +while not stop_requested(): + var = x2cscope.get_variable("myVar") + print(f"Value: {var.get_value()}") + time.sleep(0.5) + +print("Script stopped gracefully") +``` + +--- + +## Script that Works Both Standalone and in App + +Use `globals().get()` to check if variables are injected: + +```python +from pyx2cscope.x2cscope import X2CScope +from pyx2cscope.utils import get_elf_file_path +import time + +# Use injected x2cscope or create our own +if globals().get("x2cscope") is None: + x2cscope = X2CScope(port="COM3", elf_file=get_elf_file_path()) + +# Use injected stop_requested or a dummy +stop_requested = globals().get("stop_requested", lambda: False) + +while not stop_requested(): + var = x2cscope.get_variable("myVar") + print(var.get_value()) + time.sleep(0.5) +``` + +--- + +## Create Your Own Connection (Standalone Mode) + +If you want to run independently from the GUI connection: + +```python +from pyx2cscope.x2cscope import X2CScope + +# Create new connection (will fail if GUI is already connected!) +my_scope = X2CScope(port="COM3", elf_file="path/to/your.elf") + +# Use my_scope instead of x2cscope +var = my_scope.get_variable("myVar") +print(var.get_value()) +``` + +> **Note:** Creating your own connection while the GUI is connected to the same port will cause conflicts! + +--- + +## Scope Data Example + +```python +# Add scope channels +var1 = x2cscope.get_variable("channel1") +x2cscope.add_scope_channel(var1) + +# Request data +x2cscope.request_scope_data() + +# Wait and get data +import time +time.sleep(0.5) +if x2cscope.is_scope_data_ready(): + data = x2cscope.get_scope_channel_data() + print(data) +``` + +--- + +## Tips + +1. Always check if **x2cscope** is available before using it +2. Use `print()` statements - output appears in **Script Output** tab +3. Use `stop_requested()` in loops so the **Stop** button works +4. Enable "Log output to file" to save output to a file +5. The script runs in the same process as the GUI, so avoid blocking operations that take too long +6. Changes made to variables affect the actual hardware! diff --git a/pyx2cscope/gui/web/app.py b/pyx2cscope/gui/web/app.py index e51185ee..6f37a90b 100644 --- a/pyx2cscope/gui/web/app.py +++ b/pyx2cscope/gui/web/app.py @@ -25,11 +25,15 @@ def create_app(): """ app = Flask(__name__) + from pyx2cscope.gui.web.views.dashboard_view import dv_bp as dashboard_view from pyx2cscope.gui.web.views.scope_view import sv_bp as scope_view + from pyx2cscope.gui.web.views.script_view import script_bp as script_view from pyx2cscope.gui.web.views.watch_view import wv_bp as watch_view - app.register_blueprint(watch_view, url_prefix="/watch-view") - app.register_blueprint(scope_view, url_prefix="/scope-view") + app.register_blueprint(watch_view, url_prefix="/watch") + app.register_blueprint(scope_view, url_prefix="/scope") + app.register_blueprint(dashboard_view, url_prefix="/dashboard") + app.register_blueprint(script_view, url_prefix="/scripting") app.add_url_rule("/", view_func=index) app.add_url_rule("/serial-ports", view_func=list_serial_ports) @@ -66,23 +70,63 @@ def connect(): call {server_url}/connect to execute. """ - uart = request.form.get("uart") + interface_type = request.form.get("interfaceType") elf_file = request.files.get("elfFile") - if "default" not in uart and elf_file and elf_file.filename.endswith(".elf"): + + interface_kwargs = {} + + if interface_type == "CAN": + # CAN baudrate string to numeric mapping + baudrate_map = { + "125K": 125000, + "250K": 250000, + "500K": 500000, + "1M": 1000000, + } + can_bus_type = request.form.get("canBusType", "USB") + can_channel = int(request.form.get("canChannel", 1)) + can_baudrate = request.form.get("canBaudrate", "125K") + can_mode = request.form.get("canMode", "Standard") + can_tx_id = request.form.get("canTxId", "7F1") + can_rx_id = request.form.get("canRxId", "7F0") + + interface_kwargs = { + "bus": can_bus_type.lower(), + "channel": can_channel, + "baudrate": baudrate_map.get(can_baudrate, 125000), + "tx_id": int(can_tx_id, 16), + "rx_id": int(can_rx_id, 16), + "extended": can_mode == "Extended", + } + elif interface_type == "TCP_IP": + host = request.form.get("host", "localhost") + tcp_port = int(request.form.get("tcpPort", 12666)) + interface_kwargs = { + "host": host, + "tcp_port": tcp_port, + } + else: + # SERIAL + interface_arg_str = request.form.get("interfaceArgument") + interface_value_str = request.form.get("interfaceValue") + if interface_arg_str and interface_value_str: + interface_kwargs = {interface_arg_str: interface_value_str} + + if elf_file and elf_file.filename.endswith((".elf", ".pkl", ".yml")): web_lib_path = os.path.join(os.path.dirname(web.__file__), "upload") if not os.path.exists(web_lib_path): os.makedirs(web_lib_path) - file_name = os.path.join(web_lib_path, "elf_file.elf") + file_name = os.path.join(web_lib_path, os.path.basename(elf_file.filename)) try: elf_file.save(file_name) - web_scope.connect(port=uart) + web_scope.connect(**interface_kwargs) web_scope.set_file(file_name) return jsonify({"status": "success"}) except RuntimeError as e: return jsonify({"status": "error", "msg": str(e)}), 401 except ValueError as e: return jsonify({"status": "error", "msg": str(e)}), 401 - return jsonify({"status": "error", "msg": "COM Port or ELF file invalid."}), 400 + return jsonify({"status": "error", "msg": "Interface argument or import file invalid."}), 400 def is_connected(): @@ -107,13 +151,16 @@ def variables_autocomplete(): Receiving at least 3 letters, the function will search on pyX2Cscope parsed variables to find similar matches, returning a list of possible candidates. Access this function over {server_url}/variables. + Use the query parameter ``sfr=true`` to search SFRs instead of firmware variables. """ query = request.args.get("q", "") + sfr = request.args.get("sfr", "false").lower() == "true" items = [] if web_scope.is_connected(): + var_list = web_scope.list_sfr() if sfr else web_scope.list_variables() items = [ {"id": var, "text": var} - for var in web_scope.list_variables() + for var in var_list if query.lower() in var.lower() ] return jsonify({"items": items}) @@ -132,12 +179,30 @@ def get_variables(): def open_browser(host="localhost", web_port=5000): """Open a new browser pointing to the Flask server. + Only opens if no clients are already connected (e.g., from a previous session). + Existing browser tabs will reconnect automatically via Socket.IO. + Args: host (str): the host address/name web_port (int): the host port. """ - socketio.sleep(1) - webbrowser.open("http://" + host + ":" + str(web_port)) + # Wait for any existing browser tabs to reconnect + socketio.sleep(2) + + # Check if any clients are already connected via Socket.IO + has_clients = False + try: + if hasattr(socketio.server, 'eio') and hasattr(socketio.server.eio, 'sockets'): + has_clients = len(socketio.server.eio.sockets) > 0 + except Exception: + pass + + if not has_clients: + url = "http://" + ("localhost" if host == "0.0.0.0" else host) + ":" + str(web_port) + webbrowser.open(url) + print("Browser opened: " + url) + else: + print("Browser tab already connected - refresh the page to reflect changes") def main(host="localhost", web_port=5000, new=True, *args, **kwargs): diff --git a/pyx2cscope/gui/web/scope.py b/pyx2cscope/gui/web/scope.py index 0f202db1..691436f7 100644 --- a/pyx2cscope/gui/web/scope.py +++ b/pyx2cscope/gui/web/scope.py @@ -25,6 +25,10 @@ def __init__(self): self.scope_sample_time = 1 self.scope_time_sampling = 50e-3 + self.dashboard_vars = {} # {var_name: Variable object} + self.dashboard_rate = 1.0 # Fixed at 1 second for dashboard polling + self.dashboard_next = time.time() + self.x2c_scope :X2CScope | None = None self._lock = extensions.create_lock() @@ -60,7 +64,7 @@ def _get_scope_variable_as_dict(self, variable): "trigger": 0, "enable": 1, "variable": variable, - "color": colors[len(self.scope_vars)], + "color": colors[len(self.scope_vars) % len(colors)], "gain": 1, "offset": 0, "remove": 0, @@ -133,18 +137,19 @@ def clear_watch_var(self): """Clear all watch variables.""" self.watch_vars.clear() - def add_watch_var(self, var): + def add_watch_var(self, var, sfr: bool = False): """Add a variable to the watch list. Args: var (str): Variable name to add. + sfr (bool): Whether to retrieve a peripheral register (SFR) instead of a firmware variable. Returns: dict | None: Variable data dictionary if successful, None otherwise. """ var_dict = None if not any(_data["variable"].info.name == var for _data in self.watch_vars): - variable = self.x2c_scope.get_variable(var) + variable = self.x2c_scope.get_variable(var, sfr=sfr) if variable is not None: var_dict = self._get_watch_variable_as_dict(variable) self.watch_vars.append(var_dict) @@ -184,24 +189,83 @@ def watch_poll(self): return result + # Dashboard variable methods + def add_dashboard_var(self, name): + """Add a variable to the dashboard polling list. + + Args: + name (str): Variable name to add. + + Returns: + bool: True if variable was added successfully. + """ + if name not in self.dashboard_vars: + variable = self.x2c_scope.get_variable(name) + if variable is not None: + self.dashboard_vars[name] = variable + return True + return False + + def remove_dashboard_var(self, name): + """Remove a variable from the dashboard polling list. + + Args: + name (str): Variable name to remove. + """ + self.dashboard_vars.pop(name, None) + + def write_dashboard_var(self, name, value): + """Write a value to a device variable from a dashboard widget. + + Args: + name (str): Variable name. + value: Value to write. + """ + variable = self.dashboard_vars.get(name) + if variable is not None: + with self._lock: + variable.set_value(float(value)) + + def dashboard_poll(self): + """Poll all dashboard variables and return updated values. + + Returns: + dict: Dictionary of {var_name: value} for all dashboard variables. + """ + if not self.dashboard_vars: + return {} + current_time = time.time() + if current_time < self.dashboard_next: + return {} + self.dashboard_next = current_time + self.dashboard_rate + result = {} + with self._lock: + for name, variable in self.dashboard_vars.items(): + try: + result[name] = variable.get_value() + except Exception: + pass + return result + def clear_scope_var(self): """Clear all scope variables.""" with self._lock: self.scope_vars.clear() self.x2c_scope.clear_all_scope_channel() - def add_scope_var(self, var): + def add_scope_var(self, var, sfr: bool = False): """Add a variable to the scope channel list. Args: var (str): Variable name to add. + sfr (bool): Whether to retrieve a peripheral register (SFR) instead of a firmware variable. Returns: dict | None: Variable data dictionary if successful, None otherwise. """ var_dict = None if not any(data["variable"].info.name == var for data in self.scope_vars): - variable = self.x2c_scope.get_variable(var) + variable = self.x2c_scope.get_variable(var, sfr=sfr) if variable is not None: var_dict = self._get_scope_variable_as_dict(variable) self.scope_vars.append(var_dict) @@ -299,34 +363,50 @@ def scope_poll(self): """Poll scope data and return datasets when ready. Returns: - dict: Dictionary containing datasets and labels, or empty dict. + tuple: (scope_view_data, dashboard_scope_data) where scope_view_data is + a dict with datasets and labels (or empty dict), and dashboard_scope_data + is a dict of {var_name: [samples]} with raw data for all scope channels. """ with self._lock: if self.scope_trigger: if self.x2c_scope.is_scope_data_ready(): - datasets = self.get_scope_datasets() + channel_data = self.x2c_scope.get_scope_channel_data() + datasets = self._get_scope_datasets(channel_data, self.scope_vars) size = len(datasets[0]["data"]) if len(datasets) > 0 else 1000 labels = self.get_scope_chart_label(size) + # Build raw data dict for dashboard (gain/offset applied per channel) + dashboard_data = {} + for channel in self.scope_vars: + name = channel["variable"].info.name + if name in channel_data: + dashboard_data[name] = [ + sample * channel["gain"] + channel["offset"] + for sample in channel_data[name] + ] + if self.scope_burst: self.scope_burst = False self.scope_trigger = False else: self.x2c_scope.request_scope_data() - return {"datasets": datasets, "labels": labels} - return {} + return {"datasets": datasets, "labels": labels}, dashboard_data + return {}, {} - def get_scope_datasets(self): - """Get scope channel datasets. + @staticmethod + def _get_scope_datasets(channel_data, scope_vars): + """Build scope chart datasets from channel data. + + Args: + channel_data (dict): Raw channel data from X2CScope. + scope_vars (list): List of scope variable dictionaries. Returns: list: List of dataset dictionaries for each channel. """ data = [] - channel_data = self.x2c_scope.get_scope_channel_data() - for channel in self.scope_vars: - # if variable is disabled on scope_data, it is not available on channel_data + for channel in scope_vars: if channel["variable"].info.name in channel_data: variable = channel["variable"].info.name data_line = [ @@ -342,6 +422,15 @@ def get_scope_datasets(self): data.append(item) return data + def get_scope_datasets(self): + """Get scope channel datasets. + + Returns: + list: List of dataset dictionaries for each channel. + """ + channel_data = self.x2c_scope.get_scope_channel_data() + return self._get_scope_datasets(channel_data, self.scope_vars) + def get_scope_chart_label(self, size=100): """Generate time labels for scope chart. @@ -378,6 +467,14 @@ def list_variables(self): """ return self.x2c_scope.list_variables() + def list_sfr(self): + """List all available SFR (Special Function Register) names. + + Returns: + list: List of SFR names. + """ + return self.x2c_scope.list_sfr() + def disconnect(self): """Disconnect from X2CScope.""" self.x2c_scope.disconnect() diff --git a/pyx2cscope/gui/web/static/css/dashboard.css b/pyx2cscope/gui/web/static/css/dashboard.css new file mode 100644 index 00000000..e2fa0516 --- /dev/null +++ b/pyx2cscope/gui/web/static/css/dashboard.css @@ -0,0 +1,143 @@ +.dashboard-widget { + position: absolute; + background: white; + border: 2px solid #dee2e6; + border-radius: 8px; + padding: 12px; + box-shadow: 0 2px 8px rgba(0,0,0,0.1); + min-width: 200px; + min-height: 100px; +} + +.dashboard-widget.edit-mode { + cursor: move; + overflow: auto; +} + +.dashboard-widget.edit-mode.selected { + resize: both; +} + +.dashboard-widget.view-mode { + cursor: default; + resize: none !important; + border-color: transparent; + box-shadow: none; + background: transparent; +} + +.dashboard-widget.edit-mode:not(.selected) { + border-style: dashed; + border-color: #adb5bd; + opacity: 0.9; +} + +.dashboard-widget.edit-mode:not(.selected):hover { + border-color: #6c757d; + opacity: 1; +} + +.dashboard-widget.selected { + border-color: #0d6efd; + border-style: solid; + box-shadow: 0 0 0 3px rgba(13, 110, 253, 0.25); +} + +.widget-header { + display: flex; + justify-content: space-between; + align-items: center; + margin-bottom: 8px; + padding-bottom: 6px; + border-bottom: 1px solid #dee2e6; +} + +.widget-title { + font-weight: 600; + color: #495057; + font-size: 0.85rem; + display: flex; + align-items: center; + gap: 4px; +} + +.widget-controls { + display: flex; + gap: 4px; +} + +.widget-controls .btn { + padding: 0; + width: 24px; + height: 24px; + display: flex; + align-items: center; + justify-content: center; + border: none; + background: transparent; +} + +.widget-controls .btn:hover { + background: #f8f9fa; + border-radius: 4px; +} + +.widget-controls .btn .material-icons { + font-size: 18px; +} + +.view-mode .widget-controls { + display: none; +} + +.widget-content { + margin-top: 8px; +} + +.widget-content-only { + margin: 0; +} + +.dashboard-widget input[type="range"], +.dashboard-widget input[type="number"], +.dashboard-widget input[type="text"] { + width: 100%; +} + +.dashboard-widget .btn { + width: 100%; +} + +.value-display { + font-size: 1.25rem; + color: #212529; + text-align: center; + padding: 4px; + font-weight: 500; +} + +.gauge-container, +.plot-container { + width: 100%; + min-height: 150px; + height: 100%; +} + +.dashboard-widget.edit-mode.selected::after { + content: '⋰'; + position: absolute; + bottom: 5px; + right: 5px; + color: #adb5bd; + font-size: 16px; + pointer-events: none; +} + +.view-mode .dashboard-widget::after { + display: none; +} + +/* Label widgets don't block interactions with widgets underneath in view mode */ +.dashboard-widget.widget-type-label.view-mode { + pointer-events: none; +} \ No newline at end of file diff --git a/pyx2cscope/gui/web/static/js/dashboard_view.js b/pyx2cscope/gui/web/static/js/dashboard_view.js new file mode 100644 index 00000000..c6b9c5d4 --- /dev/null +++ b/pyx2cscope/gui/web/static/js/dashboard_view.js @@ -0,0 +1,1049 @@ +// Dashboard View JavaScript +// This file handles all dashboard widget functionality + +let dashboardWidgets = []; +let selectedWidget = null; +let isDashboardEditMode = true; +let draggedWidget = null; +let dragOffsetX = 0; +let dragOffsetY = 0; +let currentWidgetType = ''; +let widgetIdCounter = 0; +let dashboardSocket = null; +let scopeSocket = null; // Separate socket for scope-related commands + +// Track chart.js instances per-widget +let dashboardCharts = {}; + +// Initialize widget types registry (widgets register themselves here) +if (typeof window.dashboardWidgetTypes === 'undefined') { + window.dashboardWidgetTypes = {}; +} + +// Initialize dashboard when page loads (use 'load' to ensure widget scripts have registered) +window.addEventListener('load', function() { + initializeDashboard(); +}); + +function initializeDashboard() { + // Populate widget palette from registered widget types + populateWidgetPalette(); + + // Initialize Socket.IO if available + if (typeof io !== 'undefined') { + dashboardSocket = io('/dashboard'); + + dashboardSocket.on('connect', () => { + console.log('Dashboard connected to server'); + registerAllDashboardVariables(); + }); + + dashboardSocket.on('dashboard_data_update', (data) => { + // data is {var1: value1, var2: value2, ...} — for watch-like widgets only + for (let varName in data) { + updateDashboardWatchWidgets(varName, data[varName]); + } + }); + + dashboardSocket.on('dashboard_scope_update', (data) => { + // data is {var1: [...], var2: [...]} — for plot_scope widgets only + for (let varName in data) { + updateDashboardScopeWidgets(varName, data[varName]); + } + }); + + // Connect to scope-view namespace for sending scope trigger commands + scopeSocket = io('/scope-view'); + scopeSocket.on('connect', () => { + console.log('Dashboard connected to scope-view namespace'); + // Fetch current scope variables via HTTP + fetchScopeVariables(); + }); + + // Listen for scope table updates (variables added/removed) + scopeSocket.on('scope_table_update', (data) => { + console.log('Scope table update:', data); + // Refetch variables when scope table changes + fetchScopeVariables(); + }); + + // Listen for sample control updates + scopeSocket.on('sample_control_updated', (response) => { + if (response.status === 'success' && response.data) { + updateScopeControlSampleState(response.data); + } + }); + + // Listen for trigger control updates + scopeSocket.on('trigger_control_updated', (response) => { + if (response.status === 'success' && response.data) { + updateScopeControlTriggerState(response.data); + } + }); + + } + + // Set up file input for import + document.getElementById('dashboardFileInput').addEventListener('change', handleDashboardFileImport); + + // Set up canvas click handler for deselecting widgets + initCanvasClickHandler(); + + // Fetch scope variables via HTTP + fetchScopeVariables(); + + // Initialize UI for edit mode (default state) + initEditModeUI(); +} + +function initEditModeUI() { + const btn = document.getElementById('dashboardModeBtn'); + const icon = btn?.querySelector('.material-icons'); + const palette = document.getElementById('widgetPalette'); + const canvasCol = document.getElementById('dashboardCanvasCol'); + const canvas = document.getElementById('dashboardCanvas'); + + if (isDashboardEditMode) { + if (icon) { + icon.textContent = 'edit'; + icon.classList.remove('text-secondary'); + icon.classList.add('text-success'); + } + if (btn) btn.title = 'Edit Mode (Active)'; + if (palette) palette.style.display = 'block'; + if (canvasCol) { + canvasCol.classList.remove('col-12'); + canvasCol.classList.add('col-12', 'col-md-9', 'col-lg-10'); + } + if (canvas) { + canvas.classList.remove('view-mode'); + canvas.classList.add('edit-mode'); + } + } +} + +// Track scope variables list from scope-view +window.scopeVariablesList = []; + +// Fetch scope variables from server +function fetchScopeVariables() { + fetch('/scope/data') + .then(response => response.json()) + .then(data => { + if (data.data) { + window.scopeVariablesList = data.data.map(v => v.variable); + updateScopeControlVariables(); + } + }) + .catch(err => console.log('Could not fetch scope variables:', err)); +} + +// Update scope control widgets when variables change +function updateScopeControlVariables() { + dashboardWidgets + .filter(w => w.type === 'scope_control') + .forEach(widget => { + // Update trigger variable dropdown + const dropdown = document.getElementById(`scopeCtrlTriggerVar-${widget.id}`); + if (dropdown) { + // Use saved widget.triggerVar if dropdown is empty (initial load) + const currentValue = dropdown.value || widget.triggerVar || ''; + dropdown.innerHTML = ''; + (window.scopeVariablesList || []).forEach(v => { + const opt = document.createElement('option'); + opt.value = v; + opt.textContent = v; + if (v === currentValue) opt.selected = true; + dropdown.appendChild(opt); + }); + } + }); +} + +// Update scope control sample state +function updateScopeControlSampleState(data) { + if (data.triggerAction) { + scopeControlState = data.triggerAction; + } + dashboardWidgets + .filter(w => w.type === 'scope_control') + .forEach(widget => { + // Update sample time/freq if elements exist + const sampleTimeEl = document.getElementById('scopeCtrlSampleTime'); + const sampleFreqEl = document.getElementById('scopeCtrlSampleFreq'); + if (sampleTimeEl && data.sampleTime) sampleTimeEl.value = data.sampleTime; + if (sampleFreqEl && data.sampleFreq) sampleFreqEl.value = data.sampleFreq; + + // Update button states + const widgetEl = document.getElementById(`dashboard-widget-${widget.id}`); + if (widgetEl) { + const widgetDef = window.dashboardWidgetTypes[widget.type]; + if (widgetDef?.refresh) widgetDef.refresh(widget, widgetEl); + } + }); +} + +// Update scope control trigger state +function updateScopeControlTriggerState(data) { + dashboardWidgets + .filter(w => w.type === 'scope_control') + .forEach(widget => { + // Update trigger mode + if (data.trigger_mode !== undefined) { + const enableRadio = document.getElementById(`scopeCtrlTriggerEnable-${widget.id}`); + const disableRadio = document.getElementById(`scopeCtrlTriggerDisable-${widget.id}`); + if (enableRadio && disableRadio) { + enableRadio.checked = data.trigger_mode === '1' || data.trigger_mode === 1; + disableRadio.checked = data.trigger_mode === '0' || data.trigger_mode === 0; + } + } + // Update trigger edge + if (data.trigger_edge !== undefined) { + const risingRadio = document.getElementById(`scopeCtrlEdgeRising-${widget.id}`); + const fallingRadio = document.getElementById(`scopeCtrlEdgeFalling-${widget.id}`); + if (risingRadio && fallingRadio) { + risingRadio.checked = data.trigger_edge === '1' || data.trigger_edge === 1; + fallingRadio.checked = data.trigger_edge === '0' || data.trigger_edge === 0; + } + } + // Update trigger level (snake_case from backend) + if (data.trigger_level !== undefined) { + const levelEl = document.getElementById(`scopeCtrlTriggerLevel-${widget.id}`); + if (levelEl) levelEl.value = data.trigger_level; + } + // Update trigger delay (snake_case from backend) + if (data.trigger_delay !== undefined) { + const delayEl = document.getElementById(`scopeCtrlTriggerDelay-${widget.id}`); + if (delayEl) delayEl.value = data.trigger_delay; + } + }); +} + +// Sync scope control settings to backend after loading dashboard +function syncScopeControlToBackend() { + if (!scopeSocket || !scopeSocket.connected) { + // Retry after a short delay if socket not ready + setTimeout(syncScopeControlToBackend, 500); + return; + } + + // First: Register plot_scope variables with scope view + dashboardWidgets + .filter(w => w.type === 'plot_scope') + .forEach(widget => { + if (widget.variables) { + widget.variables.forEach(v => { + // Check if not already in scope view + if (!window.scopeVariablesList.includes(v)) { + scopeSocket.emit('add_scope_var', { var: v }); + } + }); + } + }); + + // Find scope_control widgets and sync their settings + const scopeControlWidget = dashboardWidgets.find(w => w.type === 'scope_control'); + if (scopeControlWidget) { + // Sync sample control settings + const sampleTime = scopeControlWidget.sampleTime || 1; + const sampleFreq = scopeControlWidget.sampleFreq || 20; + const sampleFormData = `triggerAction=off&sampleTime=${sampleTime}&sampleFreq=${sampleFreq}`; + scopeSocket.emit('update_sample_control', sampleFormData); + + // Sync trigger control settings + const triggerMode = scopeControlWidget.triggerMode || '0'; + const triggerEdge = scopeControlWidget.triggerEdge || '1'; + const triggerLevel = scopeControlWidget.triggerLevel || 0; + const triggerDelay = scopeControlWidget.triggerDelay || 0; + const triggerFormData = `trigger_mode=${triggerMode}&trigger_edge=${triggerEdge}&trigger_level=${triggerLevel}&trigger_delay=${triggerDelay}`; + scopeSocket.emit('update_trigger_control', triggerFormData); + + // Sync trigger variable selection (wait for variables to be registered first) + const triggerVar = scopeControlWidget.triggerVar || ''; + if (triggerVar) { + // Wait for scope variables to be registered, then set trigger + setTimeout(() => { + // Refetch scope variables to ensure we have the latest list + fetch('/scope/data') + .then(response => response.json()) + .then(data => { + if (data.data) { + const scopeVars = data.data.map(v => v.variable); + scopeVars.forEach(varName => { + scopeSocket.emit('update_scope_var', { + param: varName, + field: 'trigger', + value: varName === triggerVar ? '1' : '0' + }); + }); + // Re-send trigger control settings after setting trigger variable + // This ensures the backend properly initializes the trigger + setTimeout(() => { + scopeSocket.emit('update_trigger_control', triggerFormData); + }, 500); + } + }) + .catch(err => console.log('Could not sync trigger variable:', err)); + }, 1500); + } + } +} + +function populateWidgetPalette() { + const container = document.getElementById('widgetPaletteButtons'); + if (!container || !window.dashboardWidgetTypes) return; + + container.innerHTML = ''; + + for (const [type, def] of Object.entries(window.dashboardWidgetTypes)) { + const displayName = def.name || type.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase()); + const btn = document.createElement('button'); + btn.className = 'btn btn-sm btn-outline-primary text-start'; + btn.onclick = () => showWidgetConfig(type); + btn.innerHTML = ` ${displayName}`; + container.appendChild(btn); + } +} + +function registerAllDashboardVariables() { + dashboardWidgets.forEach(widget => registerWidgetVariables(widget)); +} + +function removeAllDashboardVariables() { + dashboardWidgets.forEach(widget => unregisterWidgetVariables(widget)); +} + +function registerWidgetVariables(widget) { + if (!dashboardSocket || !dashboardSocket.connected) return; + + if (widget.type === 'plot_scope') { + // Register as shared scope channels so data flows when scope is triggered + widget.variables?.forEach(varName => { + dashboardSocket.emit('register_scope_channel', {var: varName}); + }); + } else if (widget.type === 'plot_logger') { + widget.variables?.forEach(varName => { + dashboardSocket.emit('add_dashboard_var', {var: varName}); + }); + } else if (widget.type !== 'label') { + dashboardSocket.emit('add_dashboard_var', {var: widget.variable}); + } +} + +function isVarUsedByOtherWidgets(widget, varName) { + return dashboardWidgets.some(w => { + if (w.id === widget.id) return false; + if (w.type === 'plot_logger' || w.type === 'plot_scope') { + return w.variables && w.variables.includes(varName); + } + return w.variable === varName; + }); +} + +function unregisterWidgetVariables(widget) { + if (!dashboardSocket || !dashboardSocket.connected) return; + + if (widget.type === 'plot_scope') { + widget.variables?.forEach(varName => { + if (!isVarUsedByOtherWidgets(widget, varName)) { + dashboardSocket.emit('unregister_scope_channel', {var: varName}); + } + }); + } else if (widget.type === 'plot_logger') { + widget.variables?.forEach(varName => { + if (!isVarUsedByOtherWidgets(widget, varName)) { + dashboardSocket.emit('remove_dashboard_var', {var: varName}); + } + }); + } else if (widget.type !== 'label') { + if (!isVarUsedByOtherWidgets(widget, widget.variable)) { + dashboardSocket.emit('remove_dashboard_var', {var: widget.variable}); + } + } +} + +function toggleDashboardMode() { + isDashboardEditMode = !isDashboardEditMode; + selectedWidget = null; // Deselect any selected widget when switching modes + const btn = document.getElementById('dashboardModeBtn'); + const icon = btn.querySelector('.material-icons'); + const palette = document.getElementById('widgetPalette'); + const canvasCol = document.getElementById('dashboardCanvasCol'); + const canvas = document.getElementById('dashboardCanvas'); + + if (isDashboardEditMode) { + icon.textContent = 'edit'; + icon.classList.remove('text-secondary'); + icon.classList.add('text-success'); + btn.title = 'Edit Mode (Active)'; + palette.style.display = 'block'; + canvasCol.classList.remove('col-12'); + canvasCol.classList.add('col-12', 'col-md-9', 'col-lg-10'); + canvas.classList.remove('view-mode'); + canvas.classList.add('edit-mode'); + } else { + icon.textContent = 'visibility'; + icon.classList.remove('text-success'); + icon.classList.add('text-secondary'); + btn.title = 'View Mode'; + palette.style.display = 'none'; + canvasCol.classList.remove('col-md-9', 'col-lg-10'); + canvasCol.classList.add('col-12'); + canvas.classList.remove('edit-mode'); + canvas.classList.add('view-mode'); + } + + // Update all widgets + dashboardWidgets.forEach(w => renderDashboardWidget(w)); +} + +function initWidgetVarSelect2(options = {}) { + const defaults = { + placeholder: "Select a variable", + allowClear: true, + dropdownParent: $('#widgetConfigModal'), + ajax: { + url: '/variables', + dataType: 'json', + delay: 250, + data: function(params) { + return { q: params.term, sfr: $('#widgetSfrToggle').is(':checked') }; + }, + processResults: function (data) { + return { results: data.items }; + }, + cache: false + }, + minimumInputLength: 3 + }; + return $.extend(true, {}, defaults, options); +} + +function reinitWidgetVarSelect2() { + if ($('#widgetVarName').data('select2')) { + $('#widgetVarName').val(null).trigger('change'); + $('#widgetVarName').select2('destroy'); + } + $('#widgetVarName').select2(initWidgetVarSelect2()); +} + +function showWidgetConfig(type, editWidget = null) { + currentWidgetType = type; + const extraConfig = document.getElementById('widgetExtraConfig'); + const varNameContainer = document.getElementById('widgetVarNameContainer'); + const modalTitle = document.querySelector('#widgetConfigModal .modal-title'); + + // Get widget type definition from modular system + const widgetDef = window.dashboardWidgetTypes[type]; + if (!widgetDef) { + console.error(`Unknown widget type: ${type}`); + return; + } + + extraConfig.innerHTML = ''; + modalTitle.textContent = editWidget ? 'Edit Widget Configuration' : 'Configure Widget'; + + // Destroy previous Select2 instances + if ($('#widgetVarName').data('select2')) { + $('#widgetVarName').select2('destroy'); + } + + // Show/hide the single variable selector based on widget type + if (widgetDef.requiresMultipleVariables || !widgetDef.requiresVariable) { + varNameContainer.style.display = 'none'; + } else { + varNameContainer.style.display = ''; + // Reset and populate for edit mode + $('#widgetVarName').empty(); + if (editWidget) { + $('#widgetVarName').append(new Option(editWidget.variable, editWidget.variable, true, true)); + } + } + + // Get widget-specific configuration HTML + if (widgetDef.getConfig) { + extraConfig.innerHTML = widgetDef.getConfig(editWidget); + } + + const modal = new bootstrap.Modal(document.getElementById('widgetConfigModal')); + modal.show(); + + // Initialize Select2 after modal is shown so dropdown renders correctly + $('#widgetConfigModal').one('shown.bs.modal', function() { + // Reset SFR toggle for each new config session + $('#widgetSfrToggle').prop('checked', false); + + if (widgetDef.requiresVariable && !widgetDef.requiresMultipleVariables) { + $('#widgetVarName').select2(initWidgetVarSelect2()); + if (editWidget) { + $('#widgetVarName').prop('disabled', true); + } + // Reinitialize select2 when SFR toggle changes + $('#widgetSfrToggle').off('change.widgetVarSelect2').on('change.widgetVarSelect2', function() { + if (!$('#widgetVarName').prop('disabled')) { + reinitWidgetVarSelect2(); + } + }); + } + if (widgetDef.initSelect2) { + widgetDef.initSelect2(editWidget); + } + }); + + // Store reference to widget being edited + window.editingWidget = editWidget; +} + +function addDashboardWidget() { + const editWidget = window.editingWidget; + const widgetDef = window.dashboardWidgetTypes[currentWidgetType]; + + if (!widgetDef) { + console.error(`Unknown widget type: ${currentWidgetType}`); + return; + } + + let widget; + if (editWidget) { + // Editing existing widget + widget = editWidget; + } else { + // Creating new widget + const varName = widgetDef.requiresMultipleVariables ? '' : ($('#widgetVarName').val() || ''); + if (!varName && widgetDef.requiresVariable) { + alert('Please select a variable name'); + return; + } + + widget = { + id: widgetIdCounter++, + type: currentWidgetType, + variable: varName, + icon: widgetDef.icon, + x: 50, + y: 50, + value: currentWidgetType === 'text' ? '' : 0 + }; + } + + // Call widget-specific save config + if (widgetDef.saveConfig) { + const result = widgetDef.saveConfig(widget); + if (result === false) return; // Config validation failed + } + + if (!editWidget) { + dashboardWidgets.push(widget); + registerWidgetVariables(widget); + } + + renderDashboardWidget(widget); + + // Close modal and clean up Select2 + const modal = bootstrap.Modal.getInstance(document.getElementById('widgetConfigModal')); + modal.hide(); + if ($('#widgetVarName').data('select2')) { + $('#widgetVarName').val(null).trigger('change'); + } + if ($('#widgetVariables').data('select2')) { + $('#widgetVariables').val(null).trigger('change'); + } + window.editingWidget = null; +} + +// Helper function to parse values that might be numbers, booleans, or strings +function parseValue(val) { + if (val === 'true') return true; + if (val === 'false') return false; + const num = parseFloat(val); + if (!isNaN(num)) return num; + return val; +} + +// Select a widget in edit mode +function selectDashboardWidget(id) { + if (!isDashboardEditMode) return; + + const prevSelectedId = selectedWidget; + + // Update selection state first (before re-rendering) + if (selectedWidget === id) { + selectedWidget = null; // Toggle off if clicking same widget + } else { + selectedWidget = id; + } + + // Re-render previous widget (now deselected) + if (prevSelectedId !== null && prevSelectedId !== id) { + const prevWidget = dashboardWidgets.find(w => w.id === prevSelectedId); + if (prevWidget) renderDashboardWidget(prevWidget); + } + + // Re-render clicked widget (selected or deselected) + const widget = dashboardWidgets.find(w => w.id === id); + if (widget) renderDashboardWidget(widget); +} + +// Deselect widget when clicking on canvas background +function initCanvasClickHandler() { + const canvas = document.getElementById('dashboardCanvas'); + if (canvas) { + canvas.addEventListener('click', (e) => { + if (e.target === canvas && selectedWidget !== null) { + const prevSelectedId = selectedWidget; + selectedWidget = null; // Update state first + const prevWidget = dashboardWidgets.find(w => w.id === prevSelectedId); + if (prevWidget) renderDashboardWidget(prevWidget); + } + }); + } +} + +// This is the major override for rendering widgets and using Chart.js for gauge/plot +function renderDashboardWidget(widget) { + let widgetEl = document.getElementById(`dashboard-widget-${widget.id}`); + const isSelected = selectedWidget === widget.id; + + if (!widgetEl) { + widgetEl = document.createElement('div'); + widgetEl.id = `dashboard-widget-${widget.id}`; + widgetEl.className = `dashboard-widget widget-type-${widget.type}`; + widgetEl.style.left = widget.x + 'px'; + widgetEl.style.top = widget.y + 'px'; + + // Set saved dimensions if available + if (widget.width) widgetEl.style.width = widget.width + 'px'; + if (widget.height) widgetEl.style.height = widget.height + 'px'; + + widgetEl.addEventListener('mousedown', startDashboardDrag); + widgetEl.addEventListener('click', (e) => { + e.stopPropagation(); + selectDashboardWidget(widget.id); + }); + + // Save dimensions on resize + const resizeObserver = new ResizeObserver(entries => { + for (let entry of entries) { + const id = parseInt(entry.target.id.replace('dashboard-widget-', '')); + const w = dashboardWidgets.find(w => w.id === id); + if (w) { + w.width = entry.contentRect.width + 24; + w.height = entry.contentRect.height + 24; + } + } + }); + resizeObserver.observe(widgetEl); + + document.getElementById('dashboardCanvas').appendChild(widgetEl); + } + + // Update widget classes based on mode and selection + if (isDashboardEditMode) { + widgetEl.classList.add('edit-mode'); + widgetEl.classList.remove('view-mode'); + if (isSelected) { + widgetEl.classList.add('selected'); + } else { + widgetEl.classList.remove('selected'); + } + } else { + widgetEl.classList.remove('edit-mode', 'selected'); + widgetEl.classList.add('view-mode'); + } + + // Get widget definition from modular system + const widgetDef = window.dashboardWidgetTypes[widget.type]; + if (!widgetDef) { + console.error(`Unknown widget type: ${widget.type}`); + return; + } + + let content = ''; + const typeIcons = ``; + const displayName = widget.type === 'plot_logger' || widget.type === 'plot_scope' + ? widget.variables?.join(', ') || widget.variable + : widget.variable; + + // Show header only in edit mode when widget is selected + if (isDashboardEditMode && isSelected) { + const header = ` + + '; + } else { + // View mode or unselected edit mode: show only widget content + content = ``; + } + + widgetEl.innerHTML = content; + + // Call afterRender if widget has it + if (widgetDef.afterRender) { + widgetDef.afterRender(widget); + } +} + +// Chart.js plot rendering (line) +function renderDashboardPlot(widget, plotCanvas) { + if (dashboardCharts[widget.id]) { + dashboardCharts[widget.id].destroy(); + } + // Default colors if no custom settings + const defaultColors = ['#0d6efd', '#dc3545', '#198754', '#ffc107', '#0dcaf0', '#6f42c1', '#fd7e14', '#20c997']; + let datasets = []; + let maxLen = 0; + + if (widget.variables && widget.variables.length > 0) { + widget.variables.forEach((varName, idx) => { + const rawData = widget.data[varName] || []; + if (rawData.length > maxLen) maxLen = rawData.length; + + // Get per-variable settings (color, gain, offset) + const settings = widget.varSettings?.[varName] || {}; + const color = settings.color || defaultColors[idx % defaultColors.length]; + const gain = settings.gain !== undefined ? settings.gain : 1; + const offset = settings.offset !== undefined ? settings.offset : 0; + + // Apply gain and offset to data + const processedData = rawData.map(v => (v * gain) + offset); + + datasets.push({ + label: varName, + data: processedData, + borderColor: color, + backgroundColor: color, + tension: 0.1, + pointRadius: 0, + fill: false, + }); + }); + } + + // Generate X-axis labels + let labels = []; + let xLabel = widget.xLabel || 'Sample'; + + if (widget.type === 'plot_scope' && typeof generateTimeLabels === 'function') { + const timeData = generateTimeLabels(maxLen); + labels = timeData.labels; + xLabel = `Time (${timeData.unit})`; + } else { + labels = Array.from({length: maxLen}, (_, i) => i + 1); + } + + const yLabel = widget.yLabel || 'Value'; + const showLegend = widget.showLegend !== false; // default true + + dashboardCharts[widget.id] = new Chart(plotCanvas, { + type: 'line', + data: { + labels: labels, + datasets: datasets + }, + options: { + responsive: true, + maintainAspectRatio: false, + plugins: { + legend: {display: showLegend, position: 'top'}, + zoom: (window.Chart && Chart.HasOwnProperty && Chart.hasOwnProperty('zoom')) ? { + pan: {enabled: true, modifierKey: 'ctrl'}, + zoom: {wheel: {enabled: true}, pinch: {enabled: true}, mode: 'xy'} + } : undefined + }, + animation: {duration: 0}, + scales: { + x: { + title: {display: true, text: xLabel}, + ticks: {autoSkip: true, maxTicksLimit: 20} + }, + y: { + title: {display: true, text: yLabel} + } + } + } + }); +} + +function updateDashboardVariable(varName, value) { + // Update local widget state + const widgets = dashboardWidgets.filter(w => { + if (w.type === 'plot_logger' || w.type === 'plot_scope') { + return w.variables && w.variables.includes(varName); + } + return w.variable === varName; + }); + + // Find the first matching widget with gain/offset to reverse for device write + const refWidget = widgets.find(w => w.variable === varName && w.type !== 'plot_logger' && w.type !== 'plot_scope'); + const rawValue = refWidget ? reverseGainOffset(value, refWidget) : value; + + widgets.forEach(widget => { + if (widget.type === 'plot_logger') { + if (!widget.data) widget.data = {}; + if (!widget.data[varName]) widget.data[varName] = []; + widget.data[varName].push(value); + if (widget.data[varName].length > widget.maxPoints) { + widget.data[varName].shift(); + } + } else if (widget.type === 'plot_scope') { + if (!widget.data) widget.data = {}; + widget.data[varName] = Array.isArray(value) ? value : [value]; + } else { + widget.value = value; + } + refreshWidgetInPlace(widget); + }); + + // Send raw (reversed) value to server via Socket.IO or HTTP + if (dashboardSocket && dashboardSocket.connected) { + dashboardSocket.emit('widget_interaction', { + variable: varName, + value: rawValue + }); + } else { + fetch('/dashboard-view/update', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify({ variable: varName, value: rawValue }) + }); + } +} + +// Apply gain/offset: displayed = raw * gain + offset +function applyGainOffset(rawValue, widget) { + const gain = widget.gain !== undefined ? widget.gain : 1; + const offset = widget.offset !== undefined ? widget.offset : 0; + return rawValue * gain + offset; +} + +// Reverse gain/offset for writing: raw = (displayed - offset) / gain +function reverseGainOffset(displayedValue, widget) { + const gain = widget.gain !== undefined ? widget.gain : 1; + const offset = widget.offset !== undefined ? widget.offset : 0; + return gain !== 0 ? (displayedValue - offset) / gain : displayedValue; +} + +// Separate routing — watch data only updates non-scope widgets +function updateDashboardWatchWidgets(varName, value) { + dashboardWidgets.forEach(widget => { + if (widget.type === 'plot_scope') return; // scope data handled separately + + // Check if widget should be updated based on its update rate setting + if (window.shouldUpdateWidget && !window.shouldUpdateWidget(widget)) return; + + if (widget.type === 'plot_logger') { + if (!widget.variables || !widget.variables.includes(varName)) return; + if (!widget.data) widget.data = {}; + if (!widget.data[varName]) widget.data[varName] = []; + widget.data[varName].push(applyGainOffset(value, widget)); + if (widget.data[varName].length > widget.maxPoints) { + widget.data[varName].shift(); + } + refreshWidgetInPlace(widget); + } else if (widget.variable === varName && widget.type !== 'label') { + widget.value = applyGainOffset(value, widget); + refreshWidgetInPlace(widget); + } + }); +} + +// Scope data only updates plot_scope widgets +function updateDashboardScopeWidgets(varName, value) { + dashboardWidgets.forEach(widget => { + if (widget.type !== 'plot_scope') return; + if (!widget.variables || !widget.variables.includes(varName)) return; + if (!widget.data) widget.data = {}; + widget.data[varName] = Array.isArray(value) ? value : [value]; + refreshWidgetInPlace(widget); + }); +} + +// In-place update without full re-render to avoid chart blinking +function refreshWidgetInPlace(widget) { + const widgetEl = document.getElementById(`dashboard-widget-${widget.id}`); + if (!widgetEl) { + renderDashboardWidget(widget); + return; + } + + const widgetDef = window.dashboardWidgetTypes[widget.type]; + if (widgetDef && widgetDef.refresh) { + widgetDef.refresh(widget, widgetEl); + } +} + +function deleteDashboardWidget(id) { + if (confirm('Delete this widget?')) { + const index = dashboardWidgets.findIndex(w => w.id === id); + if (index > -1) { + // Deselect if this widget is selected + if (selectedWidget === id) { + selectedWidget = null; + } + unregisterWidgetVariables(dashboardWidgets[index]); + dashboardWidgets.splice(index, 1); + const el = document.getElementById(`dashboard-widget-${id}`); + if (el) el.remove(); + // Also clean up any Chart.js instance for this widget + if (dashboardCharts[id]) { + dashboardCharts[id].destroy(); + delete dashboardCharts[id]; + } + } + } +} + +function startDashboardDrag(e) { + if (!isDashboardEditMode) return; + + const rect = e.currentTarget.getBoundingClientRect(); + const resizeZone = 20; // px from bottom-right corner + + // Don't start drag if clicking near the resize handle (bottom-right corner) + if (e.clientX > rect.right - resizeZone && e.clientY > rect.bottom - resizeZone) { + return; + } + + draggedWidget = e.currentTarget; + + dragOffsetX = e.clientX - rect.left; + dragOffsetY = e.clientY - rect.top; + + document.addEventListener('mousemove', dashboardDrag); + document.addEventListener('mouseup', stopDashboardDrag); +} + +function dashboardDrag(e) { + if (!draggedWidget) return; + + const canvas = document.getElementById('dashboardCanvas').getBoundingClientRect(); + let x = e.clientX - canvas.left - dragOffsetX; + let y = e.clientY - canvas.top - dragOffsetY; + + draggedWidget.style.left = x + 'px'; + draggedWidget.style.top = y + 'px'; +} + +function stopDashboardDrag() { + if (draggedWidget) { + const id = parseInt(draggedWidget.id.replace('dashboard-widget-', '')); + const widget = dashboardWidgets.find(w => w.id === id); + if (widget) { + widget.x = parseInt(draggedWidget.style.left); + widget.y = parseInt(draggedWidget.style.top); + } + } + + draggedWidget = null; + document.removeEventListener('mousemove', dashboardDrag); + document.removeEventListener('mouseup', stopDashboardDrag); +} + +function saveDashboardLayout() { + fetch('/dashboard-view/save-layout', { + method: 'POST', + headers: { 'Content-Type': 'application/json' }, + body: JSON.stringify(dashboardWidgets) + }) + .then(r => r.json()) + .then(data => { + alert(data.message || 'Layout saved successfully'); + }) + .catch(err => { + console.error('Error saving layout:', err); + alert('Error saving layout'); + }); +} + +function loadDashboardLayout() { + fetch('/dashboard-view/load-layout') + .then(r => r.json()) + .then(data => { + if (data.status === 'success') { + removeAllDashboardVariables(); + dashboardWidgets = data.layout; + widgetIdCounter = Math.max(...dashboardWidgets.map(w => w.id), 0) + 1; + document.getElementById('dashboardCanvas').innerHTML = ''; + dashboardWidgets.forEach(w => renderDashboardWidget(w)); + registerAllDashboardVariables(); + syncScopeControlToBackend(); + alert('Layout loaded successfully'); + } else { + alert(data.message || 'No saved layout found'); + } + }) + .catch(err => { + console.error('Error loading layout:', err); + alert('No saved layout found'); + }); +} + +function exportDashboardLayout() { + const dataStr = JSON.stringify(dashboardWidgets, null, 2); + const dataBlob = new Blob([dataStr], {type: 'application/json'}); + const url = URL.createObjectURL(dataBlob); + const link = document.createElement('a'); + link.href = url; + link.download = 'dashboard_layout.json'; + link.click(); + URL.revokeObjectURL(url); +} + +function clearDashboard() { + if (dashboardWidgets.length === 0) { + alert('Dashboard is already empty'); + return; + } + if (confirm('Are you sure you want to remove all widgets from the dashboard?')) { + // Unregister all variables + removeAllDashboardVariables(); + // Destroy all chart instances + for (const id in dashboardCharts) { + dashboardCharts[id].destroy(); + delete dashboardCharts[id]; + } + // Clear widgets array + dashboardWidgets = []; + selectedWidget = null; + // Clear the canvas + document.getElementById('dashboardCanvas').innerHTML = ''; + } +} + +function importDashboardLayout() { + document.getElementById('dashboardFileInput').click(); +} + +function handleDashboardFileImport(e) { + const file = e.target.files[0]; + if (file) { + const reader = new FileReader(); + reader.onload = (event) => { + try { + removeAllDashboardVariables(); + dashboardWidgets = JSON.parse(event.target.result); + widgetIdCounter = Math.max(...dashboardWidgets.map(w => w.id), 0) + 1; + document.getElementById('dashboardCanvas').innerHTML = ''; + dashboardWidgets.forEach(w => renderDashboardWidget(w)); + registerAllDashboardVariables(); + syncScopeControlToBackend(); + alert('Layout imported successfully'); + } catch (err) { + console.error('Import error:', err); + alert('Error importing layout: Invalid JSON file'); + } + }; + reader.readAsText(file); + } +} \ No newline at end of file diff --git a/pyx2cscope/gui/web/static/js/scope_view.js b/pyx2cscope/gui/web/static/js/scope_view.js index b9f1f440..06e452bd 100644 --- a/pyx2cscope/gui/web/static/js/scope_view.js +++ b/pyx2cscope/gui/web/static/js/scope_view.js @@ -106,19 +106,31 @@ function initScopeSelect(){ url: '/variables', dataType: 'json', delay: 250, + data: function(params) { + return { q: params.term, sfr: $('#scopeSfrToggle').is(':checked') }; + }, processResults: function (data) { return { results: data.items }; }, - cache: true + cache: false }, minimumInputLength: 3 }); - $('#scopeSearch').on('select2:select', function(e){ + $('#scopeSearch').off('select2:select').on('select2:select', function(e){ parameter = $('#scopeSearch').select2('data')[0]['text']; - socket_sv.emit("add_scope_var", {var: parameter}); + var sfr = $('#scopeSfrToggle').is(':checked'); + socket_sv.emit("add_scope_var", {var: parameter, sfr: sfr}); + }); + + $('#scopeSfrToggle').off('change.scopeSearch').on('change.scopeSearch', function() { + $('#scopeSearch').val(null).trigger('change'); + if ($('#scopeSearch').data('select2')) { + $('#scopeSearch').select2('destroy'); + } + initScopeSelect(); }); } @@ -379,7 +391,7 @@ function initScopeChart() { scopeChart.resetZoom(); }); - $('#chartExport').attr("href", "/scope-view/export") + $('#chartExport').attr("href", "/scope/export") } function initScopeForms(){ @@ -395,11 +407,16 @@ function initScopeForms(){ $(this).closest('.btn-group').find('.btn').removeClass('active'); // Add active class to the clicked button's label $(`label[for="${this.id}"]`).addClass('active'); - + // Submit the form $("#sampleControlForm").submit(); }); - + + // Add change event handlers for sample time and frequency inputs + $('#sampleTime, #sampleFreq').on('change', function() { + $("#sampleControlForm").submit(); + }); + // Initialize the active state of the stop button on page load $('input[name="triggerAction"][checked]').trigger('change'); @@ -411,7 +428,7 @@ function initScopeForms(){ }); // Add change event handlers for the radio buttons to update their visual state - $('input[name="triggerEnable"]').on('change', function() { + $('input[name="trigger_mode"]').on('change', function() { // Remove active class from all labels in the same button group $(this).closest('.btn-group').find('.btn').removeClass('active'); // Add active class to the clicked button's label @@ -420,7 +437,7 @@ function initScopeForms(){ // Set up Save button click handler $("#scopeSave").on("click", function() { - window.location.href = '/scope-view/save'; + window.location.href = '/scope/save'; }); $("#scopeLoad").on("change", function(event) { @@ -429,7 +446,7 @@ function initScopeForms(){ formData.append('file', file); $.ajax({ - url: '/scope-view/load', // Replace with your server upload endpoint + url: '/scope/load', // Replace with your server upload endpoint type: 'POST', data: formData, contentType: false, @@ -453,7 +470,7 @@ $(document).ready(function () { initScopeChart(); scopeTable = $('#scopeTable').DataTable({ - ajax: '/scope-view/data', + ajax: '/scope/data', searching: false, paging: false, info: false, diff --git a/pyx2cscope/gui/web/static/js/script.js b/pyx2cscope/gui/web/static/js/script.js index ca6e9dba..6d1fbdb7 100644 --- a/pyx2cscope/gui/web/static/js/script.js +++ b/pyx2cscope/gui/web/static/js/script.js @@ -1,7 +1,26 @@ function connect(){ let formData = new FormData(); - formData.append('uart', $('#uart').val()); + const interfaceType = $('#interfaceType').val(); + formData.append('interfaceType', interfaceType); + + if (interfaceType === 'SERIAL') { + formData.append('interfaceArgument', 'port'); + formData.append('interfaceValue', $('#port').val()); + } + else if (interfaceType === 'TCP_IP') { + formData.append('host', $('#host').val()); + formData.append('tcpPort', $('#tcpPort').val()); + } + else if (interfaceType === 'CAN') { + formData.append('canBusType', $('#canBusType').val()); + formData.append('canChannel', $('#canChannel').val()); + formData.append('canBaudrate', $('#canBaudrate').val()); + formData.append('canMode', $('#canMode').val()); + formData.append('canTxId', $('#canTxId').val()); + formData.append('canRxId', $('#canRxId').val()); + } + formData.append('elfFile', $('#elfFile')[0].files[0]); $.ajax({ @@ -33,7 +52,7 @@ function disconnect(){ function load_uart() { $.getJSON('/serial-ports', function(data) { - uart = $('#uart'); + uart = $('#port'); uart.empty(); uart.append(''); data.forEach(function(item) { @@ -42,6 +61,25 @@ function load_uart() { }); } +function setInterfaceSetupFields() { + const interfaceType = $('#interfaceType').val(); + + $('#uartRow').addClass('d-none'); + $('#hostRow').addClass('d-none'); + $('#canRow').addClass('d-none'); + + if (interfaceType === 'SERIAL') { + $('#uartRow').removeClass('d-none'); + load_uart(); + } + else if (interfaceType === 'TCP_IP') { + $('#hostRow').removeClass('d-none'); + } + else if (interfaceType === 'CAN') { + $('#canRow').removeClass('d-none'); + } +} + function setConnectState(status) { if(status) { parameterCardEnabled = true; @@ -49,8 +87,10 @@ function setConnectState(status) { $('#setupView').addClass('collapse'); $('#watchView').removeClass('disabled'); $('#scopeView').removeClass('disabled'); + $('#dashboardView').removeClass('disabled'); $("#btnWatchView").prop("disabled", false); $("#btnScopeView").prop("disabled", false); + $("#btnDashboardView").prop("disabled", false); $("#btnConnect").prop("disabled", true); $("#btnConnect").html("Disconnect", true); $('#connection-status').html('Connected'); @@ -64,6 +104,7 @@ function setConnectState(status) { $('#setupView').removeClass('collapse'); $('#watchView').addClass('disabled'); $('#scopeView').addClass('disabled'); + $('#dashboardView').addClass('disabled'); $("#btnConnect").prop("disabled", false); $('#connection-status').html('Disconnected'); $('#btnConnect').html('Connect'); @@ -77,10 +118,12 @@ function setConnectState(status) { function initSetupCard(){ $('#update_com_port').on('click', load_uart); + $('#interfaceType').on('change', setInterfaceSetupFields); $('#btnConnect').on('click', function() { if($('#btnConnect').html() === "Connect") connect(); else disconnect(); }); + $('#connection-status').on('click', function() { if($('#connection-status').html() === "Disconnected") connect(); else disconnect(); @@ -124,45 +167,94 @@ function initQRCodes() { insertQRCode("scope-view"); $('#x2cModal').modal('show'); }); + $("#dashboardQRCode").on("click", function() { + $('#x2cModalTitle').html('Dashboard - Scan QR Code'); + insertQRCode("dashboard-view"); + $('#x2cModal').modal('show'); + }); + $("#scriptQRCode").on("click", function() { + $('#x2cModalTitle').html('Script - Scan QR Code'); + insertQRCode("script-view"); + $('#x2cModal').modal('show'); + }); } $(document).ready(function() { initSetupCard(); - load_uart(); + setInterfaceSetupFields(); initQRCodes(); // Toggles for views const toggleWatch = document.getElementById('toggleWatch'); const toggleScope = document.getElementById('toggleScope'); + const toggleDashboard = document.getElementById('toggleDashboard'); + const toggleScript = document.getElementById('toggleScript'); const watchCol = document.getElementById('watchCol'); const scopeCol = document.getElementById('scopeCol'); + const dashboardCol = document.getElementById('dashboardCol'); + const scriptCol = document.getElementById('scriptCol'); // Mobile view (tabs) // Mobile tab click handlers document.getElementById('tabWatch').addEventListener('click', function() { watchCol.classList.remove('d-none'); scopeCol.classList.add('d-none'); + dashboardCol.classList.add('d-none'); + scriptCol.classList.add('d-none'); this.classList.add('active'); document.getElementById('tabScope').classList.remove('active'); + document.getElementById('tabDashboard').classList.remove('active'); + document.getElementById('tabScript').classList.remove('active'); }); document.getElementById('tabScope').addEventListener('click', function() { watchCol.classList.add('d-none'); scopeCol.classList.remove('d-none'); + dashboardCol.classList.add('d-none'); + scriptCol.classList.add('d-none'); this.classList.add('active'); document.getElementById('tabWatch').classList.remove('active'); + document.getElementById('tabDashboard').classList.remove('active'); + document.getElementById('tabScript').classList.remove('active'); }); - // Desktop view (toggles) - // Uncheck toggles and hide views by default on desktop + document.getElementById('tabDashboard').addEventListener('click', function() { + scopeCol.classList.add('d-none'); + watchCol.classList.add('d-none'); + dashboardCol.classList.remove('d-none'); + scriptCol.classList.add('d-none'); + this.classList.add('active'); + document.getElementById('tabWatch').classList.remove('active'); + document.getElementById('tabScope').classList.remove('active'); + document.getElementById('tabScript').classList.remove('active'); + }); + + document.getElementById('tabScript').addEventListener('click', function() { + scopeCol.classList.add('d-none'); + watchCol.classList.add('d-none'); + dashboardCol.classList.add('d-none'); + scriptCol.classList.remove('d-none'); + this.classList.add('active'); + document.getElementById('tabWatch').classList.remove('active'); + document.getElementById('tabScope').classList.remove('active'); + document.getElementById('tabDashboard').classList.remove('active'); + }); + + // Hide all view cards by default - only setup card is visible toggleWatch.checked = false; toggleScope.checked = false; + toggleDashboard.checked = false; + toggleScript.checked = false; watchCol.classList.add('d-none'); scopeCol.classList.add('d-none'); + dashboardCol.classList.add('d-none'); + scriptCol.classList.add('d-none'); // Update toggle button states document.querySelector('label[for="toggleWatch"]').classList.remove('active'); document.querySelector('label[for="toggleScope"]').classList.remove('active'); + document.querySelector('label[for="toggleDashboard"]').classList.remove('active'); + document.querySelector('label[for="toggleScript"]').classList.remove('active'); // Toggle event listeners for desktop toggleWatch.addEventListener('change', () => { @@ -175,6 +267,16 @@ $(document).ready(function() { document.querySelector('label[for="toggleScope"]').classList.toggle('active', toggleScope.checked); }); + toggleDashboard.addEventListener('change', () => { + dashboardCol.classList.toggle('d-none', !toggleDashboard.checked); + document.querySelector('label[for="toggleDashboard"]').classList.toggle('active', toggleDashboard.checked); + }); + + toggleScript.addEventListener('change', () => { + scriptCol.classList.toggle('d-none', !toggleScript.checked); + document.querySelector('label[for="toggleScript"]').classList.toggle('active', toggleScript.checked); + }); + $.getJSON('/is-connected', function(data) { setConnectState(data.status); }); diff --git a/pyx2cscope/gui/web/static/js/scripting_view.js b/pyx2cscope/gui/web/static/js/scripting_view.js new file mode 100644 index 00000000..085b4eeb --- /dev/null +++ b/pyx2cscope/gui/web/static/js/scripting_view.js @@ -0,0 +1,258 @@ +// Scripting View JavaScript +// Handles script execution with real-time output streaming + +let scriptSocket = null; +let scriptFile = null; +let isScriptRunning = false; +let scriptLogContent = ''; // Buffer for log download + +function initScriptingView() { + // Initialize Socket.IO connection for scripting + if (typeof io !== 'undefined') { + scriptSocket = io('/scripting'); + + scriptSocket.on('connect', () => { + console.log('Scripting socket connected'); + logScriptMessage('Connected to scripting server'); + }); + + scriptSocket.on('script_output', (data) => { + appendScriptOutput(data.output); + }); + + scriptSocket.on('script_finished', (data) => { + onScriptFinished(data.exit_code); + }); + + scriptSocket.on('script_error', (data) => { + appendScriptOutput('\nError: ' + data.error + '\n'); + onScriptFinished(1); + }); + } + + // File input handler + $('#scriptFileInput').on('change', function(e) { + const file = e.target.files[0]; + if (file) { + scriptFile = file; + $('#scriptPath').val(file.name); + $('#btnExecuteScript').prop('disabled', false); + logScriptMessage('Selected script: ' + file.name); + } + }); + + // Browse button + $('#btnBrowseScript').on('click', function() { + $('#scriptFileInput').click(); + }); + + // Execute button + $('#btnExecuteScript').on('click', executeScript); + + // Stop button + $('#btnStopScript').on('click', stopScript); + + // Help button + $('#btnScriptHelp').on('click', showScriptHelp); + + // Download log button + $('#btnDownloadLog').on('click', downloadLog); + + // Clear buttons + $('#btnClearScriptOutput').on('click', function() { + $('#scriptOutputText').text(''); + scriptLogContent = ''; + updateDownloadButtonState(); + }); + + $('#btnClearScriptLog').on('click', function() { + $('#scriptLogText').text(''); + }); +} + +function executeScript() { + if (!scriptFile) { + alert('Please select a script file first'); + return; + } + + if (isScriptRunning) { + logScriptMessage('A script is already running'); + return; + } + + // Clear script output and log buffer + $('#scriptOutputText').text(''); + scriptLogContent = ''; + + // Update UI state + isScriptRunning = true; + $('#btnExecuteScript').prop('disabled', true); + $('#btnStopScript').prop('disabled', false); + $('#btnDownloadLog').prop('disabled', true); + setScriptStatus('Running...', 'primary'); + + // Add header to log + const timestamp = new Date().toISOString(); + scriptLogContent += '=' .repeat(60) + '\n'; + scriptLogContent += 'Script execution started: ' + timestamp + '\n'; + scriptLogContent += 'Script: ' + scriptFile.name + '\n'; + scriptLogContent += '='.repeat(60) + '\n\n'; + + logScriptMessage('Script started: ' + scriptFile.name); + + // Read and send script content + const reader = new FileReader(); + reader.onload = function(e) { + const scriptContent = e.target.result; + + if (scriptSocket && scriptSocket.connected) { + scriptSocket.emit('execute_script', { + filename: scriptFile.name, + content: scriptContent + }); + } else { + appendScriptOutput('Error: Not connected to server\n'); + onScriptFinished(1); + } + }; + reader.readAsText(scriptFile); +} + +function stopScript() { + if (!isScriptRunning) return; + + logScriptMessage('Stop requested...'); + setScriptStatus('Stopping...', 'warning'); + + if (scriptSocket && scriptSocket.connected) { + scriptSocket.emit('stop_script'); + } +} + +function onScriptFinished(exitCode) { + isScriptRunning = false; + $('#btnExecuteScript').prop('disabled', false); + $('#btnStopScript').prop('disabled', true); + + // Add footer to log + const timestamp = new Date().toISOString(); + scriptLogContent += '\n' + '='.repeat(60) + '\n'; + scriptLogContent += 'Script finished: ' + timestamp + '\n'; + scriptLogContent += 'Exit code: ' + exitCode + '\n'; + scriptLogContent += '='.repeat(60) + '\n'; + + if (exitCode === 0) { + setScriptStatus('Completed', 'success'); + logScriptMessage('Script finished successfully'); + } else { + setScriptStatus('Finished (code ' + exitCode + ')', 'warning'); + logScriptMessage('Script finished with exit code ' + exitCode); + } + + updateDownloadButtonState(); +} + +function updateDownloadButtonState() { + $('#btnDownloadLog').prop('disabled', scriptLogContent.length === 0); +} + +function downloadLog() { + if (!scriptLogContent) { + alert('No log content to download'); + return; + } + + // Generate filename based on script name + let logFileName = 'script_log.txt'; + if (scriptFile) { + const baseName = scriptFile.name.replace('.py', ''); + logFileName = baseName + '_log.txt'; + } + + // Create blob and download + const blob = new Blob([scriptLogContent], { type: 'text/plain' }); + const url = URL.createObjectURL(blob); + const link = document.createElement('a'); + link.href = url; + link.download = logFileName; + document.body.appendChild(link); + link.click(); + document.body.removeChild(link); + URL.revokeObjectURL(url); + + logScriptMessage('Log downloaded: ' + logFileName); +} + +function setScriptStatus(text, variant) { + const statusEl = $('#scriptStatus'); + statusEl.text(text); + statusEl.removeClass('bg-secondary bg-primary bg-success bg-warning bg-danger'); + statusEl.addClass('bg-' + variant); +} + +function appendScriptOutput(text) { + const outputEl = $('#scriptOutputText'); + outputEl.append(text); + // Auto-scroll to bottom + outputEl.scrollTop(outputEl[0].scrollHeight); + + // Also append to log buffer + scriptLogContent += text; +} + +function logScriptMessage(message) { + const timestamp = new Date().toLocaleTimeString(); + const formatted = '[' + timestamp + '] ' + message + '\n'; + const logEl = $('#scriptLogText'); + logEl.append(formatted); + // Auto-scroll to bottom + logEl.scrollTop(logEl[0].scrollHeight); +} + +function showScriptHelp() { + // Load help content + $.get('/scripting/help', function(data) { + $('#scriptHelpContent').html(data.html || formatHelpMarkdown(data.markdown)); + const modal = new bootstrap.Modal(document.getElementById('scriptHelpModal')); + modal.show(); + }).fail(function() { + $('#scriptHelpContent').html('Could not load help content.
'); + const modal = new bootstrap.Modal(document.getElementById('scriptHelpModal')); + modal.show(); + }); +} + +function formatHelpMarkdown(markdown) { + // Simple markdown to HTML conversion + if (!markdown) return 'No help content available.
'; + + let html = markdown + // Code blocks + .replace(/```python\n([\s\S]*?)```/g, '$1$1$1')
+ // Headers
+ .replace(/^### (.+)$/gm, '$1') + // Line breaks + .replace(/\n\n/g, '
')
+ .replace(/\n/g, '
');
+
+ return '
' + html + '
'; +} + +// Initialize when document is ready +$(document).ready(function() { + initScriptingView(); +}); diff --git a/pyx2cscope/gui/web/static/js/watch_view.js b/pyx2cscope/gui/web/static/js/watch_view.js index dad0d8ed..fb2ee5d3 100644 --- a/pyx2cscope/gui/web/static/js/watch_view.js +++ b/pyx2cscope/gui/web/static/js/watch_view.js @@ -82,7 +82,7 @@ function setParameterTableListeners(){ // Set up Save button click handler $("#parameterSave").on("click", function() { - window.location.href = '/watch-view/save'; + window.location.href = '/watch/save'; }); $('#parameterLoad').on('change', function(event) { var file = event.target.files[0]; @@ -90,7 +90,7 @@ function setParameterTableListeners(){ formData.append('file', file); $.ajax({ - url: '/watch-view/load', // Replace with your server upload endpoint + url: '/watch/load', // Replace with your server upload endpoint type: 'POST', data: formData, contentType: false, @@ -108,6 +108,7 @@ function setParameterTableListeners(){ } function initParameterSelect(){ + var sfr = $('#parameterSfrToggle').is(':checked'); $('#parameterSearch').select2({ placeholder: "Select a variable", dropdownAutoWidth : true, @@ -116,19 +117,31 @@ function initParameterSelect(){ url: '/variables', dataType: 'json', delay: 250, + data: function(params) { + return { q: params.term, sfr: $('#parameterSfrToggle').is(':checked') }; + }, processResults: function (data) { return { results: data.items }; }, - cache: true + cache: false }, minimumInputLength: 3 }); - $('#parameterSearch').on('select2:select', function(e){ + $('#parameterSearch').off('select2:select').on('select2:select', function(e){ parameter = $('#parameterSearch').select2('data')[0]['text']; - socket_wv.emit("add_watch_var", {var: parameter}); + sfr = $('#parameterSfrToggle').is(':checked'); + socket_wv.emit("add_watch_var", {var: parameter, sfr: sfr}); + }); + + $('#parameterSfrToggle').off('change.parameterSearch').on('change.parameterSearch', function() { + $('#parameterSearch').val(null).trigger('change'); + if ($('#parameterSearch').data('select2')) { + $('#parameterSearch').select2('destroy'); + } + initParameterSelect(); }); } @@ -169,7 +182,7 @@ $(document).ready(function () { setParameterRefreshInterval(); parameterTable = $('#parameterTable').DataTable({ - ajax: '/watch-view/data', + ajax: '/watch/data', searching: false, paging: false, info: false, diff --git a/pyx2cscope/gui/web/static/widgets/button/widget.js b/pyx2cscope/gui/web/static/widgets/button/widget.js new file mode 100644 index 00000000..a716a436 --- /dev/null +++ b/pyx2cscope/gui/web/static/widgets/button/widget.js @@ -0,0 +1,139 @@ +/** + * Button Widget - Push button with toggle mode support + * + * Features: + * - Momentary or Toggle mode + * - Configurable press/release values + * - Color change on press (toggle mode) + * - Supports touch and mouse events + */ + +function handleDashboardButtonPress(id) { + const widget = dashboardWidgets.find(w => w.id === id); + if (!widget) return; + + if (widget.toggleMode) { + // Toggle mode: switch state — needs full re-render for button color change + widget.buttonState = !widget.buttonState; + const value = widget.buttonState ? widget.pressValue : widget.releaseValue || 0; + updateDashboardVariable(widget.variable, value); + renderDashboardWidget(widget); // button color change requires re-render + } else { + // Momentary mode: send press value + updateDashboardVariable(widget.variable, widget.pressValue); + } +} + +function handleDashboardButtonRelease(id) { + const widget = dashboardWidgets.find(w => w.id === id); + // Don't handle release for toggle mode or if release is not enabled + if (!widget || widget.toggleMode || !widget.releaseWrite) return; + + // Momentary mode: send release value + updateDashboardVariable(widget.variable, widget.releaseValue); +} + +function createButtonWidget(widget) { + const btnColor = widget.toggleMode && widget.buttonState + ? widget.pressedColor + : widget.buttonColor; + + return ` + + `; +} + +function getButtonConfig(editWidget) { + return ` +