enode-host 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

enode_host/view.py

@@ -13,6 +13,8 @@
 ## PLEASE DO *NOT* EDIT THIS FILE!
 ###########################################################################
 
+import os
+import sys
 import wx
 import wx.xrc
 import wx.grid
@@ -28,9 +30,23 @@ from matplotlib.backends.backend_wxagg import \
     NavigationToolbar2WxAgg as NavigationToolbar
 from matplotlib.figure import Figure
 import matplotlib.dates as mdates
+import numpy as np
 import wx.grid as gridlib
+def _env_truthy(name: str) -> bool:
+    value = os.environ.get(name)
+    if not value:
+        return False
+    return value.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+if sys.platform.startswith("linux"):
+    os.environ.setdefault("WEBKIT_DISABLE_DMABUF_RENDERER", "1")
+
 try:
-    import wx.html2 as webview
+    if _env_truthy("ENODE_DISABLE_WEBVIEW"):
+        webview = None
+    else:
+        import wx.html2 as webview
 except ImportError:
     webview = None
 try:
@@ -52,6 +68,7 @@ try:
         PPS_AGE_LIMIT_SEC,
         PPS_AGE_UPDATE_MS,
         PPS_COL,
+        BAT_COL,
     )
 except ImportError:
     from constants import (
@@ -62,6 +79,7 @@ except ImportError:
         PPS_AGE_LIMIT_SEC,
         PPS_AGE_UPDATE_MS,
         PPS_COL,
+        BAT_COL,
     )
 import pandas as pd
 
@@ -147,6 +165,8 @@ class TableUpdater:
         self.grid.SetColSize(self.col_index[RSSI_COL], 40)
         self.grid.SetColSize(self.col_index["Children"], 70)
         self.grid.SetColSize(self.col_index[PPS_COL], 40)
+        if BAT_COL in self.col_index:
+            self.grid.SetColSize(self.col_index[BAT_COL], 50)
         self.grid.SetColSize(self.col_index["CMD"], 200)
         for hidden in [
             "PPS-time",
@@ -226,6 +246,7 @@ class PlotUpdater:
         self.timehistory_lines = {}
         self.psd_lines = {}
         self._psd_legend_labels = {}
+        self.psd_auto_x = True
 
     def init_plot(self):
         self.timehistory_lines = {}
@@ -247,7 +268,8 @@ class PlotUpdater:
         self.axes1.set_xlabel('Time')
         self.axes1.set_ylabel('Acceleration (g)')
         self.axes1.grid(True)
-        self.axes1.set_ylim(-2, 2)
+        if not self.view.time_y_auto:
+            self.axes1.set_ylim(*self.view.time_y_limits)
         self.axes1.tick_params(axis='x', labelbottom=True, pad=2)
         self.axes1.legend()
         self.view.m_fig.figure.autofmt_xdate(rotation=0, ha='right')
@@ -265,11 +287,16 @@ class PlotUpdater:
         self.axes2.set_xlabel('Frequency (Hz)')
         self.axes2.set_ylabel('ASD (g/sq(Hz))')
         self.axes2.grid(True)
-        self.axes2.set_ylim(1e-6, 1e1)
+        if not self.view.psd_y_auto:
+            self.axes2.set_ylim(*self.view.psd_y_limits)
         self.axes2.set_xlim(0, 25)
+        self.psd_auto_x = True
+        self.axes2.callbacks.connect('xlim_changed', self._on_psd_xlim_changed)
         self.axes2.legend()
 
     def figure_update(self):
+        min_time_y = None
+        max_time_y = None
         for _, row in self.model.mesh_status_data.iterrows():
             node_id = row['nodeID']
             for idx, ch in enumerate(['X', 'Y', 'Z']):
@@ -278,30 +305,74 @@ class PlotUpdater:
                     with self.model.plot_mutex[node_id]:
                         if len(self.model.timehistory_xdata[node_id]) > 1:
                             self.timehistory_lines[node_id_ch].set_xdata(self.model.timehistory_xdata[node_id])
-                            self.timehistory_lines[node_id_ch].set_ydata(self.model.timehistory_ydata[node_id][:, idx])
+                            series = self.model.timehistory_ydata[node_id][:, idx]
+                            self.timehistory_lines[node_id_ch].set_ydata(series)
+                            if self.view.time_y_auto and series is not None and len(series) > 0:
+                                finite = series[np.isfinite(series)]
+                                if finite.size:
+                                    smin = float(finite.min())
+                                    smax = float(finite.max())
+                                    min_time_y = smin if min_time_y is None else min(min_time_y, smin)
+                                    max_time_y = smax if max_time_y is None else max(max_time_y, smax)
         if self.model.timehistory_xlim:
             self.axes1.set_xlim(self.model.timehistory_xlim)
+        if self.view.time_y_auto and min_time_y is not None and max_time_y is not None:
+            if min_time_y == max_time_y:
+                pad = 1.0 if min_time_y == 0 else abs(min_time_y) * 0.1
+            else:
+                pad = (max_time_y - min_time_y) * 0.05
+            self.axes1.set_ylim(min_time_y - pad, max_time_y + pad)
         try:
             self.view.m_fig.figure.canvas.draw()
         except Exception:
             raise
 
+        max_f = None
+        min_psd_y = None
+        max_psd_y = None
         for _, row in self.model.mesh_status_data.iterrows():
             node_id = row['nodeID']
+            f = self.model.psd_xdata.get(node_id)
             for idx, ch in enumerate(['X', 'Y', 'Z']):
                 node_id_ch = row['Node ID'] + ch
                 if node_id_ch in self.psd_lines and node_id in self.model.psd_ydata:
                     with self.model.plot_mutex[node_id]:
-                        self.psd_lines[node_id_ch].set_xdata(self.model.psd_xdata)
-                        self.psd_lines[node_id_ch].set_ydata(self.model.psd_ydata[node_id][:, idx])
-
-        if len(self.model.psd_xdata) > 0:
-            self.axes2.set_xlim(0, round(self.model.psd_xdata[-1]))
+                        if f is not None and len(f) > 0:
+                            self.psd_lines[node_id_ch].set_xdata(f)
+                            last_f = f[-1]
+                            if max_f is None or last_f > max_f:
+                                max_f = last_f
+                        series = self.model.psd_ydata[node_id][:, idx]
+                        self.psd_lines[node_id_ch].set_ydata(series)
+                        if self.view.psd_y_auto and series is not None and len(series) > 0:
+                            finite = series[np.isfinite(series)]
+                            finite = finite[finite > 0]
+                            if finite.size:
+                                smin = float(finite.min())
+                                smax = float(finite.max())
+                                min_psd_y = smin if min_psd_y is None else min(min_psd_y, smin)
+                                max_psd_y = smax if max_psd_y is None else max(max_psd_y, smax)
+
+        if self.psd_auto_x and max_f is not None:
+            self.axes2.set_xlim(0, round(max_f))
+        if self.view.psd_y_auto and min_psd_y is not None and max_psd_y is not None:
+            low = min_psd_y * 0.8
+            high = max_psd_y * 1.2
+            if low <= 0:
+                low = min_psd_y * 0.5
+            if low > 0 and high > low:
+                self.axes2.set_ylim(low, high)
         try:
             self.view.m_fig.figure.canvas.draw()
         except Exception:
             raise
 
+    def _on_psd_xlim_changed(self, _axes):
+        # Disable auto-scaling after user zoom/pan.
+        if not self.psd_auto_x:
+            return
+        self.psd_auto_x = False
+
     def update_psd_legend(self):
         if not self.psd_lines:
             return
@@ -348,6 +419,7 @@ class MergedPlotUpdater:
         self.axes2 = view.axes2_merged
         self.timehistory_lines = {}
         self.psd_lines = {}
+        self.psd_auto_x = True
 
     def _node_label(self, node_id):
         return str(node_id).upper()
@@ -370,7 +442,8 @@ class MergedPlotUpdater:
         self.axes1.set_xlabel('Time')
         self.axes1.set_ylabel('Acceleration (g)')
         self.axes1.grid(True)
-        self.axes1.set_ylim(-2, 2)
+        if not self.view.time_y_auto:
+            self.axes1.set_ylim(*self.view.time_y_limits)
         self.axes1.tick_params(axis='x', labelbottom=True, pad=2)
         self.axes1.legend()
         self.view.m_fig_merged.figure.autofmt_xdate(rotation=0, ha='right')
@@ -387,11 +460,16 @@ class MergedPlotUpdater:
         self.axes2.set_xlabel('Frequency (Hz)')
         self.axes2.set_ylabel('ASD (g/sq(Hz))')
         self.axes2.grid(True)
-        self.axes2.set_ylim(1e-6, 1e1)
+        if not self.view.psd_y_auto:
+            self.axes2.set_ylim(*self.view.psd_y_limits)
         self.axes2.set_xlim(0, 25)
+        self.psd_auto_x = True
+        self.axes2.callbacks.connect('xlim_changed', self._on_psd_xlim_changed)
         self.axes2.legend()
 
     def figure_update(self):
+        min_time_y = None
+        max_time_y = None
         for node_id in self.model.merged_node_ids:
             node_label = self._node_label(node_id)
             xdata = self.model.merged_timehistory_xdata.get(node_id)
@@ -403,14 +481,30 @@ class MergedPlotUpdater:
                 line = self.timehistory_lines.get(label)
                 if line is not None:
                     line.set_xdata(xdata)
-                    line.set_ydata(ydata[:, idx])
+                    series = ydata[:, idx]
+                    line.set_ydata(series)
+                    if self.view.time_y_auto and series is not None and len(series) > 0:
+                        finite = series[np.isfinite(series)]
+                        if finite.size:
+                            smin = float(finite.min())
+                            smax = float(finite.max())
+                            min_time_y = smin if min_time_y is None else min(min_time_y, smin)
+                            max_time_y = smax if max_time_y is None else max(max_time_y, smax)
         if self.model.merged_timehistory_xlim:
             self.axes1.set_xlim(self.model.merged_timehistory_xlim)
+        if self.view.time_y_auto and min_time_y is not None and max_time_y is not None:
+            if min_time_y == max_time_y:
+                pad = 1.0 if min_time_y == 0 else abs(min_time_y) * 0.1
+            else:
+                pad = (max_time_y - min_time_y) * 0.05
+            self.axes1.set_ylim(min_time_y - pad, max_time_y + pad)
         try:
             self.view.m_fig_merged.figure.canvas.draw()
         except Exception:
             raise
 
+        min_psd_y = None
+        max_psd_y = None
         f = self.model.merged_psd_xdata
         if f is None:
             f = []
@@ -424,15 +518,37 @@ class MergedPlotUpdater:
                 line = self.psd_lines.get(label)
                 if line is not None:
                     line.set_xdata(f)
-                    line.set_ydata(ydata[:, idx])
-
-        if len(f) > 0:
+                    series = ydata[:, idx]
+                    line.set_ydata(series)
+                    if self.view.psd_y_auto and series is not None and len(series) > 0:
+                        finite = series[np.isfinite(series)]
+                        finite = finite[finite > 0]
+                        if finite.size:
+                            smin = float(finite.min())
+                            smax = float(finite.max())
+                            min_psd_y = smin if min_psd_y is None else min(min_psd_y, smin)
+                            max_psd_y = smax if max_psd_y is None else max(max_psd_y, smax)
+
+        if self.psd_auto_x and len(f) > 0:
             self.axes2.set_xlim(0, round(f[-1]))
+        if self.view.psd_y_auto and min_psd_y is not None and max_psd_y is not None:
+            low = min_psd_y * 0.8
+            high = max_psd_y * 1.2
+            if low <= 0:
+                low = min_psd_y * 0.5
+            if low > 0 and high > low:
+                self.axes2.set_ylim(low, high)
         try:
             self.view.m_fig_merged.figure.canvas.draw()
         except Exception:
             raise
 
+    def _on_psd_xlim_changed(self, _axes):
+        # Disable auto-scaling after user zoom/pan.
+        if not self.psd_auto_x:
+            return
+        self.psd_auto_x = False
+
 ###########################################################################
 ## Class View
 ###########################################################################
@@ -447,12 +563,19 @@ class View(wx.Frame):
         self.model = self.controller.model
         if self.model is not None:
             self.timespan_length = self.model.timespan_length
+        else:
+            self.timespan_length = 30
         self.m_table = None
         self.table_updater = None
         self.plot_updater = None
         self.merged_plot_updater = None
         self.PPS_outdate_check = True 
         self.channel_selection = [False, True, False]
+        self.time_y_auto = False
+        self.time_y_limits = (-2.0, 2.0)
+        self.psd_y_auto = False
+        self.psd_y_limits = (1e-6, 1e1)
+        self._load_plot_options()
 
         self.SetSizeHints( wx.DefaultSize, wx.DefaultSize )
 
@@ -479,17 +602,14 @@ class View(wx.Frame):
         self.m_panel_status = wx.Panel(self.m_left_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.m_panel_map = wx.Panel(self.m_left_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.m_panel_plots = wx.Panel(self.m_left_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
-        self.m_panel_merged_plots = wx.Panel(self.m_left_notebook, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         self.m_left_notebook.AddPage(self.m_panel_nodes, _(u"Nodes"), False)
         self.m_left_notebook.AddPage(self.m_panel_status, _(u"Mesh"), True)
         self.m_left_notebook.AddPage(self.m_panel_map, _(u"Map"), False)
-        self.m_left_notebook.AddPage(self.m_panel_plots, _(u"RT-Plot"), False)
-        self.m_left_notebook.AddPage(self.m_panel_merged_plots, _(u"Merged Plot"), False)
+        self.m_left_notebook.AddPage(self.m_panel_plots, _(u"Plots"), False)
         self.tab_index_nodes = 0
         self.tab_index_status = 1
         self.tab_index_map = 2
         self.tab_index_rt_plots = 3
-        self.tab_index_merged_plots = 4
 
         # Sensor Nodes definition tab
         nodes_sizer = wx.BoxSizer(wx.VERTICAL)
@@ -505,7 +625,7 @@ class View(wx.Frame):
             self.controller.model.options.get('acc_nums_txt', '[1:3]'),
             wx.DefaultPosition,
             wx.DefaultSize,
-            0,
+            wx.TE_PROCESS_ENTER,
         )
         nodes_grid.Add(self.m_textCtrl_acc, 1, wx.EXPAND)
 
@@ -517,7 +637,7 @@ class View(wx.Frame):
             self.controller.model.options.get('tmp_nums_txt', '[]'),
             wx.DefaultPosition,
             wx.DefaultSize,
-            0,
+            wx.TE_PROCESS_ENTER,
         )
         nodes_grid.Add(self.m_textCtrl_tmp, 1, wx.EXPAND)
 
@@ -529,7 +649,7 @@ class View(wx.Frame):
             self.controller.model.options.get('str_nums_txt', '[]'),
             wx.DefaultPosition,
             wx.DefaultSize,
-            0,
+            wx.TE_PROCESS_ENTER,
         )
         nodes_grid.Add(self.m_textCtrl_str, 1, wx.EXPAND)
 
@@ -541,7 +661,7 @@ class View(wx.Frame):
             self.controller.model.options.get('veh_nums_txt', '[]'),
             wx.DefaultPosition,
             wx.DefaultSize,
-            0,
+            wx.TE_PROCESS_ENTER,
         )
         nodes_grid.Add(self.m_textCtrl_veh, 1, wx.EXPAND)
 
@@ -573,6 +693,7 @@ class View(wx.Frame):
             self.m_map = webview.WebView.New(self.m_panel_map)
             map_sizer.Add(self.m_map, 1, wx.ALL | wx.EXPAND, 5)
             self.m_map_loaded = False
+            self._map_nodes = set()
             self.m_map.Bind(webview.EVT_WEBVIEW_LOADED, self.on_map_loaded)
             self._load_map()
         else:
@@ -586,14 +707,88 @@ class View(wx.Frame):
         self.m_panel_map.SetSizer(map_sizer)
 
         plots_sizer = wx.BoxSizer(wx.VERTICAL)
+
+        plot_controls_sizer = wx.BoxSizer(wx.HORIZONTAL)
+
+        self.m_button_clf = wx.Button(self.m_panel_plots, wx.ID_ANY, _(u"Clear Figure"), wx.DefaultPosition, wx.DefaultSize, 0)
+        plot_controls_sizer.Add(self.m_button_clf, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+
+        plot_controls_sizer.Add(wx.StaticText(self.m_panel_plots, wx.ID_ANY, _(u"Channels:")), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+        self.m_check_chx = wx.CheckBox(self.m_panel_plots, wx.ID_ANY, _(u"X"))
+        self.m_check_chy = wx.CheckBox(self.m_panel_plots, wx.ID_ANY, _(u"Y"))
+        self.m_check_chz = wx.CheckBox(self.m_panel_plots, wx.ID_ANY, _(u"Z"))
+        self.m_check_chx.SetValue(self.channel_selection[0])
+        self.m_check_chy.SetValue(self.channel_selection[1])
+        self.m_check_chz.SetValue(self.channel_selection[2])
+        plot_controls_sizer.Add(self.m_check_chx, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+        plot_controls_sizer.Add(self.m_check_chy, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+        plot_controls_sizer.Add(self.m_check_chz, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+
+        plot_controls_sizer.Add(wx.StaticText(self.m_panel_plots, wx.ID_ANY, _(u"Timespan:")), 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+        self.timespan_choices = [30, 20, 10, 5, 2]
+        self.m_choice_timespan = wx.Choice(
+            self.m_panel_plots,
+            choices=[f"{v} sec" for v in self.timespan_choices],
+        )
+        if self.timespan_length in self.timespan_choices:
+            self.m_choice_timespan.SetSelection(self.timespan_choices.index(self.timespan_length))
+        else:
+            self.m_choice_timespan.SetSelection(0)
+        plot_controls_sizer.Add(self.m_choice_timespan, 0, wx.ALL | wx.ALIGN_CENTER_VERTICAL, 4)
+
+        plots_sizer.Add(plot_controls_sizer, 0, wx.EXPAND | wx.LEFT | wx.RIGHT | wx.TOP, 5)
+
+        ylim_sizer = wx.FlexGridSizer(1, 6, 2, 6)
+        ylim_sizer.AddGrowableCol(2, 1)
+        ylim_sizer.AddGrowableCol(5, 1)
+
+        self.m_check_time_y_auto = wx.CheckBox(self.m_panel_plots, wx.ID_ANY, _(u"Time Y auto"))
+        self.m_check_time_y_auto.SetValue(self.time_y_auto)
+        ylim_sizer.Add(self.m_check_time_y_auto, 0, wx.ALIGN_CENTER_VERTICAL)
+        ylim_sizer.Add(wx.StaticText(self.m_panel_plots, wx.ID_ANY, _(u"ylim:")), 0, wx.ALIGN_CENTER_VERTICAL)
+        self.m_text_time_ylim = wx.TextCtrl(
+            self.m_panel_plots,
+            wx.ID_ANY,
+            f"[{self.time_y_limits[0]}, {self.time_y_limits[1]}]",
+            wx.DefaultPosition,
+            wx.Size(120, -1),
+            wx.TE_PROCESS_ENTER,
+        )
+        self.m_text_time_ylim.Enable(not self.time_y_auto)
+        ylim_sizer.Add(self.m_text_time_ylim, 0, wx.ALIGN_CENTER_VERTICAL)
+
+        self.m_check_psd_y_auto = wx.CheckBox(self.m_panel_plots, wx.ID_ANY, _(u"ASD Y auto"))
+        self.m_check_psd_y_auto.SetValue(self.psd_y_auto)
+        ylim_sizer.Add(self.m_check_psd_y_auto, 0, wx.ALIGN_CENTER_VERTICAL)
+        ylim_sizer.Add(wx.StaticText(self.m_panel_plots, wx.ID_ANY, _(u"ylim:")), 0, wx.ALIGN_CENTER_VERTICAL)
+        self.m_text_psd_ylim = wx.TextCtrl(
+            self.m_panel_plots,
+            wx.ID_ANY,
+            f"[{self.psd_y_limits[0]}, {self.psd_y_limits[1]}]",
+            wx.DefaultPosition,
+            wx.Size(120, -1),
+            wx.TE_PROCESS_ENTER,
+        )
+        self.m_text_psd_ylim.Enable(not self.psd_y_auto)
+        ylim_sizer.Add(self.m_text_psd_ylim, 0, wx.ALIGN_CENTER_VERTICAL)
+
+        ylim_row = wx.BoxSizer(wx.HORIZONTAL)
+        indent = self.m_button_clf.GetBestSize().width + 8
+        ylim_row.AddSpacer(indent)
+        ylim_row.Add(ylim_sizer, 0, wx.ALIGN_CENTER_VERTICAL)
+        plots_sizer.Add(ylim_row, 0, wx.LEFT | wx.RIGHT | wx.BOTTOM, 5)
         self.m_plot_panel = wx.Panel(self.m_panel_plots, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
         plots_sizer.Add(self.m_plot_panel, 1, wx.ALL | wx.EXPAND, 5)
         self.m_panel_plots.SetSizer(plots_sizer)
 
-        merged_plots_sizer = wx.BoxSizer(wx.VERTICAL)
-        self.m_plot_panel_merged = wx.Panel(self.m_panel_merged_plots, wx.ID_ANY, wx.DefaultPosition, wx.DefaultSize, wx.TAB_TRAVERSAL)
-        merged_plots_sizer.Add(self.m_plot_panel_merged, 1, wx.ALL | wx.EXPAND, 5)
-        self.m_panel_merged_plots.SetSizer(merged_plots_sizer)
+        self.m_check_chx.Bind(wx.EVT_CHECKBOX, self.onChannelToggled)
+        self.m_check_chy.Bind(wx.EVT_CHECKBOX, self.onChannelToggled)
+        self.m_check_chz.Bind(wx.EVT_CHECKBOX, self.onChannelToggled)
+        self.m_choice_timespan.Bind(wx.EVT_CHOICE, self.onTimeSpanChange)
+        self.m_check_time_y_auto.Bind(wx.EVT_CHECKBOX, self.on_time_y_auto_toggle)
+        self.m_text_time_ylim.Bind(wx.EVT_TEXT_ENTER, self.on_time_ylim_enter)
+        self.m_check_psd_y_auto.Bind(wx.EVT_CHECKBOX, self.on_psd_y_auto_toggle)
+        self.m_text_psd_ylim.Bind(wx.EVT_TEXT_ENTER, self.on_psd_ylim_enter)
 
         bSizer3.Add(self.m_left_notebook, 1, wx.ALL | wx.EXPAND, 5)
         bSizer1.Add( bSizer3, 1, wx.EXPAND, 5 )
@@ -613,6 +808,7 @@ class View(wx.Frame):
                 "SD Stream Start",
                 "SD Stream Stop",
                 "SD Clear All",
+                "Shutdown",
             ],
         )
         cmd_choice_sizer.Add(self.m_choice_OperationMode, 0, wx.ALL | wx.CENTER, 5)
@@ -681,46 +877,6 @@ class View(wx.Frame):
         self.m_menu_data.AppendSubMenu(self.m_menu_data_clear, _(u"Clear"))
         self.m_menubar.Append(self.m_menu_data, _(u"&Data"))
 
-        self.m_menu_cmd = wx.Menu()
-        self.m_menu_cmd_sdclear = wx.MenuItem(self.m_menu_cmd, wx.ID_ANY, _(u"SD &Clear"), wx.EmptyString, wx.ITEM_NORMAL)
-        self.m_menu_cmd.Append(self.m_menu_cmd_sdclear)
-        self.m_menu_cmd_shutdown = wx.MenuItem(self.m_menu_cmd, wx.ID_ANY, _(u"&Shutdown"), wx.EmptyString, wx.ITEM_NORMAL)
-        self.m_menu_cmd.Append(self.m_menu_cmd_shutdown)
-        self.m_menubar.Append(self.m_menu_cmd, _(u"&CMD"))
-
-
-        self.m_menu_view = wx.Menu()
-        self.m_menu_view_clf = wx.MenuItem(self.m_menu_view, wx.ID_ANY, _(u"&Clear Figure"), wx.EmptyString, wx.ITEM_NORMAL)
-        self.m_menu_view.Append(self.m_menu_view_clf)
-
-        self.m_menu_view_chsel = wx.Menu()
-        self.m_menu_view_chsel_x = self.m_menu_view_chsel.AppendCheckItem(wx.ID_ANY, "X")
-        self.m_menu_view_chsel_y = self.m_menu_view_chsel.AppendCheckItem(wx.ID_ANY, "Y")
-        self.m_menu_view_chsel_z = self.m_menu_view_chsel.AppendCheckItem(wx.ID_ANY, "Z")
-        self.m_menu_view_chsel_y.Check(True)
-        self.m_menu_view.AppendSubMenu(self.m_menu_view_chsel, "Channel Selection")
-        self.Bind(wx.EVT_MENU, self.onChannelToggled, self.m_menu_view_chsel_x)
-        self.Bind(wx.EVT_MENU, self.onChannelToggled, self.m_menu_view_chsel_y)
-        self.Bind(wx.EVT_MENU, self.onChannelToggled, self.m_menu_view_chsel_z)
-        
-
-        self.m_menu_view_timespan = wx.Menu()
-        self.m_menu_view_timespan_radio_30s = self.m_menu_view_timespan.AppendRadioItem(wx.ID_ANY, "30 sec")
-        self.m_menu_view_timespan_radio_20s = self.m_menu_view_timespan.AppendRadioItem(wx.ID_ANY, "20 sec")
-        self.m_menu_view_timespan_radio_10s = self.m_menu_view_timespan.AppendRadioItem(wx.ID_ANY, "10 sec")
-        self.m_menu_view_timespan_radio_05s = self.m_menu_view_timespan.AppendRadioItem(wx.ID_ANY, "5 sec")
-        self.m_menu_view_timespan_radio_02s = self.m_menu_view_timespan.AppendRadioItem(wx.ID_ANY, "2 sec")
-        self.m_menu_view_timespan_radio_30s.Check(True)
-        self.m_menu_view.AppendSubMenu(self.m_menu_view_timespan, "Timespan Select")
-        self.Bind(wx.EVT_MENU, self.onTimeSpanChange, self.m_menu_view_timespan_radio_30s)
-        self.Bind(wx.EVT_MENU, self.onTimeSpanChange, self.m_menu_view_timespan_radio_20s)
-        self.Bind(wx.EVT_MENU, self.onTimeSpanChange, self.m_menu_view_timespan_radio_10s)
-        self.Bind(wx.EVT_MENU, self.onTimeSpanChange, self.m_menu_view_timespan_radio_05s)
-        self.Bind(wx.EVT_MENU, self.onTimeSpanChange, self.m_menu_view_timespan_radio_02s)
-
-
-        self.m_menubar.Append(self.m_menu_view, _(u"&View"))
-
         self.m_menu_help = wx.Menu()
         self.m_menu_help_about = wx.MenuItem(self.m_menu_help, wx.ID_ANY, _(u"&Help"), wx.EmptyString, wx.ITEM_NORMAL)
         self.m_menu_help.Append(self.m_menu_help_about)
@@ -739,23 +895,25 @@ class View(wx.Frame):
         self.plot_updater = PlotUpdater(self)
         self.plot_updater.init_plot()
         self.m_plot_canvas = self.m_fig.canvas
-        sizer = wx.BoxSizer(wx.VERTICAL)
-        sizer.Add(self.m_fig, 1, wx.EXPAND)
-        self.m_plot_panel.SetSizer(sizer)
         self.m_plot_canvas.Bind(wx.EVT_LEFT_DOWN, self._focus_plot_canvas)
 
-        self.m_fig_merged = Plot(self.m_plot_panel_merged)
+        self.m_fig_merged = Plot(self.m_plot_panel)
         self.axes1_merged = self.m_fig_merged.figure.add_subplot(2, 1, 1)
         self.axes2_merged = self.m_fig_merged.figure.add_subplot(2, 1, 2)
         self.m_fig_merged.figure.subplots_adjust(hspace=0.28, bottom=0.08, top=0.95)
         self.merged_plot_updater = MergedPlotUpdater(self)
         self.merged_plot_updater.init_plot()
         self.m_plot_canvas_merged = self.m_fig_merged.canvas
-        merged_sizer = wx.BoxSizer(wx.VERTICAL)
-        merged_sizer.Add(self.m_fig_merged, 1, wx.EXPAND)
-        self.m_plot_panel_merged.SetSizer(merged_sizer)
         self.m_plot_canvas_merged.Bind(wx.EVT_LEFT_DOWN, self._focus_plot_canvas)
 
+        plot_stack = wx.BoxSizer(wx.VERTICAL)
+        plot_stack.Add(self.m_fig, 1, wx.EXPAND)
+        plot_stack.Add(self.m_fig_merged, 1, wx.EXPAND)
+        self.m_fig_merged.Hide()
+        self.m_plot_panel.SetSizer(plot_stack)
+        self._plot_stack = plot_stack
+        self._active_plot = "rt"
+
         # UPDATE TIMERS
 
         self._last_plot_version = 0
@@ -796,14 +954,6 @@ class View(wx.Frame):
         self.m_left_notebook.Bind(wx.EVT_NOTEBOOK_PAGE_CHANGED, self.on_tab_changed)
 
 
-        self.timespan_map = {
-            self.m_menu_view_timespan_radio_30s.GetId(): 30,
-            self.m_menu_view_timespan_radio_20s.GetId(): 20,
-            self.m_menu_view_timespan_radio_10s.GetId(): 10,
-            self.m_menu_view_timespan_radio_05s.GetId(): 5,
-            self.m_menu_view_timespan_radio_02s.GetId(): 2,
-        }
-
     def mesh_status_data_view(self):
         if self.table_updater is None:
             self.table_updater = TableUpdater(self)
@@ -821,6 +971,15 @@ class View(wx.Frame):
             self.m_textCtrl_tmp,
             self.m_textCtrl_str,
             self.m_textCtrl_veh,
+            getattr(self, "m_button_clf", None),
+            getattr(self, "m_check_chx", None),
+            getattr(self, "m_check_chy", None),
+            getattr(self, "m_check_chz", None),
+            getattr(self, "m_choice_timespan", None),
+            getattr(self, "m_check_time_y_auto", None),
+            getattr(self, "m_text_time_ylim", None),
+            getattr(self, "m_check_psd_y_auto", None),
+            getattr(self, "m_text_psd_ylim", None),
             getattr(self, "m_plot_canvas", None),
             getattr(self, "m_plot_canvas_merged", None),
         ):
@@ -900,9 +1059,32 @@ class View(wx.Frame):
             return
         self.merged_plot_updater.figure_update()
 
+    def _set_active_plot(self, mode: str):
+        if mode not in ("rt", "merged"):
+            return
+        if getattr(self, "_active_plot", None) == mode:
+            return
+        self._active_plot = mode
+        if mode == "merged":
+            self.m_fig.Hide()
+            self.m_fig_merged.Show()
+        else:
+            self.m_fig_merged.Hide()
+            self.m_fig.Show()
+        try:
+            self.m_plot_panel.Layout()
+        except Exception:
+            pass
+
+    def show_rt_plots(self):
+        self._set_active_plot("rt")
+        if hasattr(self, "tab_index_rt_plots"):
+            self.m_left_notebook.SetSelection(self.tab_index_rt_plots)
+
     def show_merged_plots(self):
-        if hasattr(self, "tab_index_merged_plots"):
-            self.m_left_notebook.SetSelection(self.tab_index_merged_plots)
+        self._set_active_plot("merged")
+        if hasattr(self, "tab_index_rt_plots"):
+            self.m_left_notebook.SetSelection(self.tab_index_rt_plots)
 
     def _focus_plot_canvas(self, event):
         try:
@@ -986,14 +1168,12 @@ class View(wx.Frame):
 
     def on_tab_changed(self, event):
         idx = event.GetSelection()
-        if idx == self.tab_index_rt_plots and hasattr(self, "m_plot_canvas"):
-            try:
-                self.m_plot_canvas.SetFocus()
-            except Exception:
-                pass
-        if idx == self.tab_index_merged_plots and hasattr(self, "m_plot_canvas_merged"):
+        if idx == self.tab_index_rt_plots:
+            canvas = self.m_plot_canvas
+            if getattr(self, "_active_plot", "rt") == "merged":
+                canvas = self.m_plot_canvas_merged
             try:
-                self.m_plot_canvas_merged.SetFocus()
+                canvas.SetFocus()
             except Exception:
                 pass
         event.Skip()
@@ -1004,10 +1184,24 @@ class View(wx.Frame):
     def map_update(self, event):
         if self.m_map is None or not self.m_map_loaded:
             return
+        connected = set()
+        if self.model is not None:
+            for _, row in self.model.mesh_status_data.iterrows():
+                if row.get("Connection") == "connected":
+                    connected.add(row.get("nodeID"))
+
+        for node_id in list(self._map_nodes):
+            if node_id not in connected:
+                safe_id = str(node_id).replace("'", "\\'")
+                self.m_map.RunScript(f"removeMarker('{safe_id}');")
+                self._map_nodes.discard(node_id)
+
         positions = getattr(self.model, "gnss_positions", {})
         if not positions:
             return
         for node_id, pos in positions.items():
+            if node_id not in connected:
+                continue
             if not pos.get("valid"):
                 continue
             lat = pos.get("lat")
@@ -1016,6 +1210,7 @@ class View(wx.Frame):
                 continue
             safe_id = str(node_id).replace("'", "\\'")
             self.m_map.RunScript(f"updateMarker('{safe_id}', {lat}, {lon});")
+            self._map_nodes.add(node_id)
 
     def _load_map(self):
         if self.m_map is None:
@@ -1043,6 +1238,26 @@ class View(wx.Frame):
               attribution: '&copy; OpenStreetMap contributors'
             }).addTo(map);
             const markers = {};
+            let bounds = L.latLngBounds();
+            let autoFit = true;
+
+            function rebuildBounds() {
+              bounds = L.latLngBounds();
+              let hasMarker = false;
+              for (const key in markers) {
+                if (!Object.prototype.hasOwnProperty.call(markers, key)) continue;
+                const latlng = markers[key].getLatLng();
+                bounds.extend(latlng);
+                hasMarker = true;
+              }
+              if (autoFit && hasMarker && bounds.isValid()) {
+                map.fitBounds(bounds.pad(0.15), {animate: false});
+              }
+            }
+
+            map.on('dragstart zoomstart', () => {
+              autoFit = false;
+            });
             window.updateMarker = function(nodeId, lat, lon) {
               let m = markers[nodeId];
               if (!m) {
@@ -1051,6 +1266,17 @@ class View(wx.Frame):
                 markers[nodeId] = m;
               }
               m.setLatLng([lat, lon]);
+              bounds.extend([lat, lon]);
+              if (autoFit && bounds.isValid()) {
+                map.fitBounds(bounds.pad(0.15), {animate: false});
+              }
+            };
+            window.removeMarker = function(nodeId) {
+              const m = markers[nodeId];
+              if (!m) return;
+              map.removeLayer(m);
+              delete markers[nodeId];
+              rebuildBounds();
             };
           </script>
         </body>
@@ -1136,14 +1362,156 @@ class View(wx.Frame):
             return
         self.plot_updater.update_psd_legend()
 
+    def _parse_ylim_text(self, text: str):
+        if text is None:
+            return None
+        raw = text.strip()
+        if not raw:
+            return None
+        if raw.startswith("[") and raw.endswith("]"):
+            raw = raw[1:-1].strip()
+        parts = [p.strip() for p in raw.split(",") if p.strip()]
+        if len(parts) != 2:
+            parts = [p.strip() for p in raw.split() if p.strip()]
+        if len(parts) != 2:
+            return None
+        try:
+            lo = float(parts[0])
+            hi = float(parts[1])
+        except (TypeError, ValueError):
+            return None
+        if lo == hi:
+            return None
+        if lo > hi:
+            lo, hi = hi, lo
+        return lo, hi
+
+    def _parse_bool_option(self, value, default: bool) -> bool:
+        if value is None:
+            return default
+        if isinstance(value, bool):
+            return value
+        text = str(value).strip().lower()
+        if text in {"1", "true", "yes", "y", "on"}:
+            return True
+        if text in {"0", "false", "no", "n", "off"}:
+            return False
+        return default
+
+    def _parse_int_option(self, value, default: int) -> int:
+        if value is None:
+            return default
+        try:
+            return int(str(value).strip())
+        except (TypeError, ValueError):
+            return default
 
-    def onChannelToggled(self, event):
-
+    def _load_plot_options(self) -> None:
+        if self.model is None:
+            return
+        options = getattr(self.model, "options", {}) or {}
         self.channel_selection = [
-            self.m_menu_view_chsel_x.IsChecked(),
-            self.m_menu_view_chsel_y.IsChecked(),
-            self.m_menu_view_chsel_z.IsChecked()
+            self._parse_bool_option(options.get("plot_channel_x"), self.channel_selection[0]),
+            self._parse_bool_option(options.get("plot_channel_y"), self.channel_selection[1]),
+            self._parse_bool_option(options.get("plot_channel_z"), self.channel_selection[2]),
         ]
+        self.timespan_length = self._parse_int_option(
+            options.get("plot_timespan"), self.timespan_length
+        )
+        self.model.timespan_length = self.timespan_length
+        self.time_y_auto = self._parse_bool_option(
+            options.get("plot_time_y_auto"), self.time_y_auto
+        )
+        time_ylim = self._parse_ylim_text(options.get("plot_time_ylim", ""))
+        if time_ylim is not None:
+            self.time_y_limits = time_ylim
+        self.psd_y_auto = self._parse_bool_option(
+            options.get("plot_psd_y_auto"), self.psd_y_auto
+        )
+        psd_ylim = self._parse_ylim_text(options.get("plot_psd_ylim", ""))
+        if psd_ylim is not None:
+            self.psd_y_limits = psd_ylim
+
+    def _persist_plot_options(self) -> None:
+        if self.model is None:
+            return
+        options = getattr(self.model, "options", None)
+        if options is None:
+            return
+        options["plot_channel_x"] = "true" if self.channel_selection[0] else "false"
+        options["plot_channel_y"] = "true" if self.channel_selection[1] else "false"
+        options["plot_channel_z"] = "true" if self.channel_selection[2] else "false"
+        options["plot_timespan"] = str(self.timespan_length)
+        options["plot_time_y_auto"] = "true" if self.time_y_auto else "false"
+        options["plot_time_ylim"] = f"[{self.time_y_limits[0]}, {self.time_y_limits[1]}]"
+        options["plot_psd_y_auto"] = "true" if self.psd_y_auto else "false"
+        options["plot_psd_ylim"] = f"[{self.psd_y_limits[0]}, {self.psd_y_limits[1]}]"
+        self.model.save_config()
+
+    def on_time_y_auto_toggle(self, event):
+        self.time_y_auto = self.m_check_time_y_auto.GetValue()
+        self.m_text_time_ylim.Enable(not self.time_y_auto)
+        self._persist_plot_options()
+        self.init_plot()
+        self.figure_update()
+        self.init_merged_plot()
+        self.figure_update_merged()
+
+    def on_psd_y_auto_toggle(self, event):
+        self.psd_y_auto = self.m_check_psd_y_auto.GetValue()
+        self.m_text_psd_ylim.Enable(not self.psd_y_auto)
+        self._persist_plot_options()
+        self.init_plot()
+        self.figure_update()
+        self.init_merged_plot()
+        self.figure_update_merged()
+
+    def on_time_ylim_enter(self, event):
+        lims = self._parse_ylim_text(self.m_text_time_ylim.GetValue())
+        if lims is None:
+            self.append_status_message("[plot] invalid time ylim (use [low, high])")
+            return
+        self.time_y_limits = lims
+        self.m_text_time_ylim.SetValue(f"[{lims[0]}, {lims[1]}]")
+        self._persist_plot_options()
+        if not self.time_y_auto:
+            self.init_plot()
+            self.figure_update()
+            self.init_merged_plot()
+            self.figure_update_merged()
+
+    def on_psd_ylim_enter(self, event):
+        lims = self._parse_ylim_text(self.m_text_psd_ylim.GetValue())
+        if lims is None:
+            self.append_status_message("[plot] invalid ASD ylim (use [low, high])")
+            return
+        self.psd_y_limits = lims
+        self.m_text_psd_ylim.SetValue(f"[{lims[0]}, {lims[1]}]")
+        self._persist_plot_options()
+        if not self.psd_y_auto:
+            self.init_plot()
+            self.figure_update()
+            self.init_merged_plot()
+            self.figure_update_merged()
+
+    def _read_channel_selection(self):
+        if hasattr(self, "m_check_chx"):
+            return [
+                self.m_check_chx.GetValue(),
+                self.m_check_chy.GetValue(),
+                self.m_check_chz.GetValue(),
+            ]
+        if hasattr(self, "m_menu_view_chsel_x"):
+            return [
+                self.m_menu_view_chsel_x.IsChecked(),
+                self.m_menu_view_chsel_y.IsChecked(),
+                self.m_menu_view_chsel_z.IsChecked(),
+            ]
+        return list(self.channel_selection)
+
+    def onChannelToggled(self, event):
+        self.channel_selection = self._read_channel_selection()
+        self._persist_plot_options()
 
         self.init_plot()
         self.figure_update()
@@ -1210,13 +1578,17 @@ class View(wx.Frame):
         event.Skip()
 
     def onTimeSpanChange(self, event):
-
-        ts = self.timespan_map.get(event.GetId(), None)
+        ts = None
+        if hasattr(self, "m_choice_timespan"):
+            idx = self.m_choice_timespan.GetSelection()
+            if idx != wx.NOT_FOUND and hasattr(self, "timespan_choices"):
+                ts = self.timespan_choices[idx]
         if ts:
             logger.info(f"Timespan selected: {ts} sec")
             self.timespan_length = ts
             if self.model is not None:
                 self.model.timespan_length = ts
+            self._persist_plot_options()
             self.init_plot()
             self.figure_update()
             self.init_merged_plot()
@@ -1228,6 +1600,6 @@ class View(wx.Frame):
     def _append_status_message(self, msg: str) -> None:
         if hasattr(self, "m_statusBar1") and self.m_statusBar1 is not None:
             self.m_statusBar1.SetStatusText(msg)
-        print(msg, flush=True)
+        logger.info("%s", msg)